xref: /openbmc/linux/arch/s390/lib/test_unwind.c (revision 0ad53fe3)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Test module for unwind_for_each_frame
4  */
5 
6 #define pr_fmt(fmt) "test_unwind: " fmt
7 #include <asm/unwind.h>
8 #include <linux/completion.h>
9 #include <linux/kallsyms.h>
10 #include <linux/kthread.h>
11 #include <linux/module.h>
12 #include <linux/timer.h>
13 #include <linux/slab.h>
14 #include <linux/string.h>
15 #include <linux/kprobes.h>
16 #include <linux/wait.h>
17 #include <asm/irq.h>
18 
19 #define BT_BUF_SIZE (PAGE_SIZE * 4)
20 
21 /*
22  * To avoid printk line limit split backtrace by lines
23  */
24 static void print_backtrace(char *bt)
25 {
26 	char *p;
27 
28 	while (true) {
29 		p = strsep(&bt, "\n");
30 		if (!p)
31 			break;
32 		pr_err("%s\n", p);
33 	}
34 }
35 
36 /*
37  * Calls unwind_for_each_frame(task, regs, sp) and verifies that the result
38  * contains unwindme_func2 followed by unwindme_func1.
39  */
40 static noinline int test_unwind(struct task_struct *task, struct pt_regs *regs,
41 				unsigned long sp)
42 {
43 	int frame_count, prev_is_func2, seen_func2_func1;
44 	const int max_frames = 128;
45 	struct unwind_state state;
46 	size_t bt_pos = 0;
47 	int ret = 0;
48 	char *bt;
49 
50 	bt = kmalloc(BT_BUF_SIZE, GFP_ATOMIC);
51 	if (!bt) {
52 		pr_err("failed to allocate backtrace buffer\n");
53 		return -ENOMEM;
54 	}
55 	/* Unwind. */
56 	frame_count = 0;
57 	prev_is_func2 = 0;
58 	seen_func2_func1 = 0;
59 	unwind_for_each_frame(&state, task, regs, sp) {
60 		unsigned long addr = unwind_get_return_address(&state);
61 		char sym[KSYM_SYMBOL_LEN];
62 
63 		if (frame_count++ == max_frames)
64 			break;
65 		if (state.reliable && !addr) {
66 			pr_err("unwind state reliable but addr is 0\n");
67 			ret = -EINVAL;
68 			break;
69 		}
70 		sprint_symbol(sym, addr);
71 		if (bt_pos < BT_BUF_SIZE) {
72 			bt_pos += snprintf(bt + bt_pos, BT_BUF_SIZE - bt_pos,
73 					   state.reliable ? " [%-7s%px] %pSR\n" :
74 							    "([%-7s%px] %pSR)\n",
75 					   stack_type_name(state.stack_info.type),
76 					   (void *)state.sp, (void *)state.ip);
77 			if (bt_pos >= BT_BUF_SIZE)
78 				pr_err("backtrace buffer is too small\n");
79 		}
80 		frame_count += 1;
81 		if (prev_is_func2 && str_has_prefix(sym, "unwindme_func1"))
82 			seen_func2_func1 = 1;
83 		prev_is_func2 = str_has_prefix(sym, "unwindme_func2");
84 	}
85 
86 	/* Check the results. */
87 	if (unwind_error(&state)) {
88 		pr_err("unwind error\n");
89 		ret = -EINVAL;
90 	}
91 	if (!seen_func2_func1) {
92 		pr_err("unwindme_func2 and unwindme_func1 not found\n");
93 		ret = -EINVAL;
94 	}
95 	if (frame_count == max_frames) {
96 		pr_err("Maximum number of frames exceeded\n");
97 		ret = -EINVAL;
98 	}
99 	if (ret)
100 		print_backtrace(bt);
101 	kfree(bt);
102 	return ret;
103 }
104 
105 /* State of the task being unwound. */
106 struct unwindme {
107 	int flags;
108 	int ret;
109 	struct task_struct *task;
110 	struct completion task_ready;
111 	wait_queue_head_t task_wq;
112 	unsigned long sp;
113 };
114 
115 static struct unwindme *unwindme;
116 
117 /* Values of unwindme.flags. */
118 #define UWM_DEFAULT		0x0
119 #define UWM_THREAD		0x1	/* Unwind a separate task. */
120 #define UWM_REGS		0x2	/* Pass regs to test_unwind(). */
121 #define UWM_SP			0x4	/* Pass sp to test_unwind(). */
122 #define UWM_CALLER		0x8	/* Unwind starting from caller. */
123 #define UWM_SWITCH_STACK	0x10	/* Use call_on_stack. */
124 #define UWM_IRQ			0x20	/* Unwind from irq context. */
125 #define UWM_PGM			0x40	/* Unwind from program check handler. */
126 
127 static __always_inline unsigned long get_psw_addr(void)
128 {
129 	unsigned long psw_addr;
130 
131 	asm volatile(
132 		"basr	%[psw_addr],0\n"
133 		: [psw_addr] "=d" (psw_addr));
134 	return psw_addr;
135 }
136 
137 #ifdef CONFIG_KPROBES
138 static int pgm_pre_handler(struct kprobe *p, struct pt_regs *regs)
139 {
140 	struct unwindme *u = unwindme;
141 
142 	u->ret = test_unwind(NULL, (u->flags & UWM_REGS) ? regs : NULL,
143 			     (u->flags & UWM_SP) ? u->sp : 0);
144 	return 0;
145 }
146 #endif
147 
148 /* This function may or may not appear in the backtrace. */
149 static noinline int unwindme_func4(struct unwindme *u)
150 {
151 	if (!(u->flags & UWM_CALLER))
152 		u->sp = current_frame_address();
153 	if (u->flags & UWM_THREAD) {
154 		complete(&u->task_ready);
155 		wait_event(u->task_wq, kthread_should_park());
156 		kthread_parkme();
157 		return 0;
158 #ifdef CONFIG_KPROBES
159 	} else if (u->flags & UWM_PGM) {
160 		struct kprobe kp;
161 		int ret;
162 
163 		unwindme = u;
164 		memset(&kp, 0, sizeof(kp));
165 		kp.symbol_name = "do_report_trap";
166 		kp.pre_handler = pgm_pre_handler;
167 		ret = register_kprobe(&kp);
168 		if (ret < 0) {
169 			pr_err("register_kprobe failed %d\n", ret);
170 			return -EINVAL;
171 		}
172 
173 		/*
174 		 * trigger specification exception
175 		 */
176 		asm volatile(
177 			"	mvcl	%%r1,%%r1\n"
178 			"0:	nopr	%%r7\n"
179 			EX_TABLE(0b, 0b)
180 			:);
181 
182 		unregister_kprobe(&kp);
183 		unwindme = NULL;
184 		return u->ret;
185 #endif
186 	} else {
187 		struct pt_regs regs;
188 
189 		memset(&regs, 0, sizeof(regs));
190 		regs.psw.addr = get_psw_addr();
191 		regs.gprs[15] = current_stack_pointer();
192 		return test_unwind(NULL,
193 				   (u->flags & UWM_REGS) ? &regs : NULL,
194 				   (u->flags & UWM_SP) ? u->sp : 0);
195 	}
196 }
197 
198 /* This function may or may not appear in the backtrace. */
199 static noinline int unwindme_func3(struct unwindme *u)
200 {
201 	u->sp = current_frame_address();
202 	return unwindme_func4(u);
203 }
204 
205 /* This function must appear in the backtrace. */
206 static noinline int unwindme_func2(struct unwindme *u)
207 {
208 	unsigned long flags;
209 	int rc;
210 
211 	if (u->flags & UWM_SWITCH_STACK) {
212 		local_irq_save(flags);
213 		local_mcck_disable();
214 		rc = call_on_stack(1, S390_lowcore.nodat_stack,
215 				   int, unwindme_func3, struct unwindme *, u);
216 		local_mcck_enable();
217 		local_irq_restore(flags);
218 		return rc;
219 	} else {
220 		return unwindme_func3(u);
221 	}
222 }
223 
224 /* This function must follow unwindme_func2 in the backtrace. */
225 static noinline int unwindme_func1(void *u)
226 {
227 	return unwindme_func2((struct unwindme *)u);
228 }
229 
230 static void unwindme_timer_fn(struct timer_list *unused)
231 {
232 	struct unwindme *u = READ_ONCE(unwindme);
233 
234 	if (u) {
235 		unwindme = NULL;
236 		u->task = NULL;
237 		u->ret = unwindme_func1(u);
238 		complete(&u->task_ready);
239 	}
240 }
241 
242 static struct timer_list unwind_timer;
243 
244 static int test_unwind_irq(struct unwindme *u)
245 {
246 	unwindme = u;
247 	init_completion(&u->task_ready);
248 	timer_setup(&unwind_timer, unwindme_timer_fn, 0);
249 	mod_timer(&unwind_timer, jiffies + 1);
250 	wait_for_completion(&u->task_ready);
251 	return u->ret;
252 }
253 
254 /* Spawns a task and passes it to test_unwind(). */
255 static int test_unwind_task(struct unwindme *u)
256 {
257 	struct task_struct *task;
258 	int ret;
259 
260 	/* Initialize thread-related fields. */
261 	init_completion(&u->task_ready);
262 	init_waitqueue_head(&u->task_wq);
263 
264 	/*
265 	 * Start the task and wait until it reaches unwindme_func4() and sleeps
266 	 * in (task_ready, unwind_done] range.
267 	 */
268 	task = kthread_run(unwindme_func1, u, "%s", __func__);
269 	if (IS_ERR(task)) {
270 		pr_err("kthread_run() failed\n");
271 		return PTR_ERR(task);
272 	}
273 	/*
274 	 * Make sure task reaches unwindme_func4 before parking it,
275 	 * we might park it before kthread function has been executed otherwise
276 	 */
277 	wait_for_completion(&u->task_ready);
278 	kthread_park(task);
279 	/* Unwind. */
280 	ret = test_unwind(task, NULL, (u->flags & UWM_SP) ? u->sp : 0);
281 	kthread_stop(task);
282 	return ret;
283 }
284 
285 static int test_unwind_flags(int flags)
286 {
287 	struct unwindme u;
288 
289 	u.flags = flags;
290 	if (u.flags & UWM_THREAD)
291 		return test_unwind_task(&u);
292 	else if (u.flags & UWM_IRQ)
293 		return test_unwind_irq(&u);
294 	else
295 		return unwindme_func1(&u);
296 }
297 
298 static int test_unwind_init(void)
299 {
300 	int failed = 0;
301 	int total = 0;
302 
303 #define TEST(flags)							\
304 do {									\
305 	pr_info("[ RUN      ] " #flags "\n");				\
306 	total++;							\
307 	if (!test_unwind_flags((flags))) {				\
308 		pr_info("[       OK ] " #flags "\n");			\
309 	} else {							\
310 		pr_err("[  FAILED  ] " #flags "\n");			\
311 		failed++;						\
312 	}								\
313 } while (0)
314 
315 	pr_info("running stack unwinder tests");
316 	TEST(UWM_DEFAULT);
317 	TEST(UWM_SP);
318 	TEST(UWM_REGS);
319 	TEST(UWM_SWITCH_STACK);
320 	TEST(UWM_SP | UWM_REGS);
321 	TEST(UWM_CALLER | UWM_SP);
322 	TEST(UWM_CALLER | UWM_SP | UWM_REGS);
323 	TEST(UWM_CALLER | UWM_SP | UWM_REGS | UWM_SWITCH_STACK);
324 	TEST(UWM_THREAD);
325 	TEST(UWM_THREAD | UWM_SP);
326 	TEST(UWM_THREAD | UWM_CALLER | UWM_SP);
327 	TEST(UWM_IRQ);
328 	TEST(UWM_IRQ | UWM_SWITCH_STACK);
329 	TEST(UWM_IRQ | UWM_SP);
330 	TEST(UWM_IRQ | UWM_REGS);
331 	TEST(UWM_IRQ | UWM_SP | UWM_REGS);
332 	TEST(UWM_IRQ | UWM_CALLER | UWM_SP);
333 	TEST(UWM_IRQ | UWM_CALLER | UWM_SP | UWM_REGS);
334 	TEST(UWM_IRQ | UWM_CALLER | UWM_SP | UWM_REGS | UWM_SWITCH_STACK);
335 #ifdef CONFIG_KPROBES
336 	TEST(UWM_PGM);
337 	TEST(UWM_PGM | UWM_SP);
338 	TEST(UWM_PGM | UWM_REGS);
339 	TEST(UWM_PGM | UWM_SP | UWM_REGS);
340 #endif
341 #undef TEST
342 	if (failed) {
343 		pr_err("%d of %d stack unwinder tests failed", failed, total);
344 		WARN(1, "%d of %d stack unwinder tests failed", failed, total);
345 	} else {
346 		pr_info("all %d stack unwinder tests passed", total);
347 	}
348 
349 	return failed ? -EINVAL : 0;
350 }
351 
352 static void test_unwind_exit(void)
353 {
354 }
355 
356 module_init(test_unwind_init);
357 module_exit(test_unwind_exit);
358 MODULE_LICENSE("GPL");
359