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/slab.h>
 13#include <linux/string.h>
 14#include <linux/kprobes.h>
 15#include <linux/wait.h>
 16#include <asm/irq.h>
 17#include <asm/delay.h>
 18
 19#define BT_BUF_SIZE (PAGE_SIZE * 4)
 20
 21/*
 22 * To avoid printk line limit split backtrace by lines
 23 */
 24static 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 */
 40static 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			kfree(bt);
 68			return -EINVAL;
 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. */
106struct 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
115static 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
127static __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
138static 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. */
149static 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. */
199static 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. */
206static noinline int unwindme_func2(struct unwindme *u)
207{
208	int rc;
209
210	if (u->flags & UWM_SWITCH_STACK) {
211		preempt_disable();
212		rc = CALL_ON_STACK(unwindme_func3, S390_lowcore.nodat_stack, 1, u);
213		preempt_enable();
214		return rc;
215	} else {
216		return unwindme_func3(u);
217	}
218}
219
220/* This function must follow unwindme_func2 in the backtrace. */
221static noinline int unwindme_func1(void *u)
222{
223	return unwindme_func2((struct unwindme *)u);
224}
225
226static void unwindme_irq_handler(struct ext_code ext_code,
227				       unsigned int param32,
228				       unsigned long param64)
229{
230	struct unwindme *u = READ_ONCE(unwindme);
231
232	if (u && u->task == current) {
233		unwindme = NULL;
234		u->task = NULL;
235		u->ret = unwindme_func1(u);
236	}
237}
238
239static int test_unwind_irq(struct unwindme *u)
240{
241	preempt_disable();
242	if (register_external_irq(EXT_IRQ_CLK_COMP, unwindme_irq_handler)) {
243		pr_info("Couldn't register external interrupt handler");
244		return -1;
245	}
246	u->task = current;
247	unwindme = u;
248	udelay(1);
249	unregister_external_irq(EXT_IRQ_CLK_COMP, unwindme_irq_handler);
250	preempt_enable();
251	return u->ret;
252}
253
254/* Spawns a task and passes it to test_unwind(). */
255static 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
285static 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
298static int test_unwind_init(void)
299{
300	int ret = 0;
301
302#define TEST(flags)							\
303do {									\
304	pr_info("[ RUN      ] " #flags "\n");				\
305	if (!test_unwind_flags((flags))) {				\
306		pr_info("[       OK ] " #flags "\n");			\
307	} else {							\
308		pr_err("[  FAILED  ] " #flags "\n");			\
309		ret = -EINVAL;						\
310	}								\
311} while (0)
312
313	TEST(UWM_DEFAULT);
314	TEST(UWM_SP);
315	TEST(UWM_REGS);
316	TEST(UWM_SWITCH_STACK);
317	TEST(UWM_SP | UWM_REGS);
318	TEST(UWM_CALLER | UWM_SP);
319	TEST(UWM_CALLER | UWM_SP | UWM_REGS);
320	TEST(UWM_CALLER | UWM_SP | UWM_REGS | UWM_SWITCH_STACK);
321	TEST(UWM_THREAD);
322	TEST(UWM_THREAD | UWM_SP);
323	TEST(UWM_THREAD | UWM_CALLER | UWM_SP);
324	TEST(UWM_IRQ);
325	TEST(UWM_IRQ | UWM_SWITCH_STACK);
326	TEST(UWM_IRQ | UWM_SP);
327	TEST(UWM_IRQ | UWM_REGS);
328	TEST(UWM_IRQ | UWM_SP | UWM_REGS);
329	TEST(UWM_IRQ | UWM_CALLER | UWM_SP);
330	TEST(UWM_IRQ | UWM_CALLER | UWM_SP | UWM_REGS);
331	TEST(UWM_IRQ | UWM_CALLER | UWM_SP | UWM_REGS | UWM_SWITCH_STACK);
332#ifdef CONFIG_KPROBES
333	TEST(UWM_PGM);
334	TEST(UWM_PGM | UWM_SP);
335	TEST(UWM_PGM | UWM_REGS);
336	TEST(UWM_PGM | UWM_SP | UWM_REGS);
337#endif
338#undef TEST
339
340	return ret;
341}
342
343static void test_unwind_exit(void)
344{
345}
346
347module_init(test_unwind_init);
348module_exit(test_unwind_exit);
349MODULE_LICENSE("GPL");