arch/s390/lib/test_unwind.c - linux/kernel/git/gregkh/driver-core - Git at Google

 // SPDX-License-Identifier: GPL-2.0-only
 /*
  * Test module for unwind_for_each_frame
  */

 #include <kunit/test.h>
 #include <asm/unwind.h>
 #include <linux/completion.h>
 #include <linux/kallsyms.h>
 #include <linux/kthread.h>
 #include <linux/ftrace.h>
 #include <linux/module.h>
 #include <linux/timer.h>
 #include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/kprobes.h>
 #include <linux/wait.h>
 #include <asm/irq.h>

 static struct kunit *current_test;

 #define BT_BUF_SIZE (PAGE_SIZE * 4)

 static bool force_bt;
 module_param_named(backtrace, force_bt, bool, 0444);
 MODULE_PARM_DESC(backtrace, "print backtraces for all tests");

 /*
  * To avoid printk line limit split backtrace by lines
  */
 static void print_backtrace(char *bt)
 {
 	char *p;

 	while (true) {
 		p = strsep(&bt, "\n");
 		if (!p)
 			break;
 		kunit_err(current_test, "%s\n", p);
 	}
 }

 /*
  * Calls unwind_for_each_frame(task, regs, sp) and verifies that the result
  * contains unwindme_func2 followed by unwindme_func1.
  */
 static noinline int test_unwind(struct task_struct *task, struct pt_regs *regs,
 				unsigned long sp)
 {
 	int frame_count, prev_is_func2, seen_func2_func1, seen_kretprobe_trampoline;
 	const int max_frames = 128;
 	struct unwind_state state;
 	size_t bt_pos = 0;
 	int ret = 0;
 	char *bt;

 	bt = kmalloc(BT_BUF_SIZE, GFP_ATOMIC);
 	if (!bt) {
 		kunit_err(current_test, "failed to allocate backtrace buffer\n");
 		return -ENOMEM;
 	}
 	/* Unwind. */
 	frame_count = 0;
 	prev_is_func2 = 0;
 	seen_func2_func1 = 0;
 	seen_kretprobe_trampoline = 0;
 	unwind_for_each_frame(&state, task, regs, sp) {
 		unsigned long addr = unwind_get_return_address(&state);
 		char sym[KSYM_SYMBOL_LEN];

 		if (frame_count++ == max_frames)
 			break;
 		if (state.reliable && !addr) {
 			kunit_err(current_test, "unwind state reliable but addr is 0\n");
 			ret = -EINVAL;
 			break;
 		}
 		sprint_symbol(sym, addr);
 		if (bt_pos < BT_BUF_SIZE) {
 			bt_pos += snprintf(bt + bt_pos, BT_BUF_SIZE - bt_pos,
 					   state.reliable ? " [%-7s%px] %pSR\n" :
 							    "([%-7s%px] %pSR)\n",
 					   stack_type_name(state.stack_info.type),
 					   (void *)state.sp, (void *)state.ip);
 			if (bt_pos >= BT_BUF_SIZE)
 				kunit_err(current_test, "backtrace buffer is too small\n");
 		}
 		frame_count += 1;
 		if (prev_is_func2 && str_has_prefix(sym, "unwindme_func1"))
 			seen_func2_func1 = 1;
 		prev_is_func2 = str_has_prefix(sym, "unwindme_func2");
 		if (str_has_prefix(sym, "__kretprobe_trampoline+0x0/"))
 			seen_kretprobe_trampoline = 1;
 	}

 	/* Check the results. */
 	if (unwind_error(&state)) {
 		kunit_err(current_test, "unwind error\n");
 		ret = -EINVAL;
 	}
 	if (!seen_func2_func1) {
 		kunit_err(current_test, "unwindme_func2 and unwindme_func1 not found\n");
 		ret = -EINVAL;
 	}
 	if (frame_count == max_frames) {
 		kunit_err(current_test, "Maximum number of frames exceeded\n");
 		ret = -EINVAL;
 	}
 	if (seen_kretprobe_trampoline) {
 		kunit_err(current_test, "__kretprobe_trampoline+0x0 in unwinding results\n");
 		ret = -EINVAL;
 	}
 	if (ret || force_bt)
 		print_backtrace(bt);
 	kfree(bt);
 	return ret;
 }

 /* State of the task being unwound. */
 struct unwindme {
 	int flags;
 	int ret;
 	struct task_struct *task;
 	struct completion task_ready;
 	wait_queue_head_t task_wq;
 	unsigned long sp;
 };

 static struct unwindme *unwindme;

 /* Values of unwindme.flags. */
 #define UWM_DEFAULT		0x0
 #define UWM_THREAD		0x1	/* Unwind a separate task. */
 #define UWM_REGS		0x2	/* Pass regs to test_unwind(). */
 #define UWM_SP			0x4	/* Pass sp to test_unwind(). */
 #define UWM_CALLER		0x8	/* Unwind starting from caller. */
 #define UWM_SWITCH_STACK	0x10	/* Use call_on_stack. */
 #define UWM_IRQ			0x20	/* Unwind from irq context. */
 #define UWM_PGM			0x40	/* Unwind from program check handler */
 #define UWM_KPROBE_ON_FTRACE	0x80	/* Unwind from kprobe handler called via ftrace. */
 #define UWM_FTRACE		0x100	/* Unwind from ftrace handler. */
 #define UWM_KRETPROBE		0x200	/* Unwind through kretprobed function. */
 #define UWM_KRETPROBE_HANDLER	0x400	/* Unwind from kretprobe handler. */

 static __always_inline struct pt_regs fake_pt_regs(void)
 {
 	struct pt_regs regs;

 	memset(&regs, 0, sizeof(regs));
 	regs.gprs[15] = current_stack_pointer;

 	asm volatile(
 		"basr	%[psw_addr],0\n"
 		: [psw_addr] "=d" (regs.psw.addr));
 	return regs;
 }

 static int kretprobe_ret_handler(struct kretprobe_instance *ri, struct pt_regs *regs)
 {
 	struct unwindme *u = unwindme;

 	if (!(u->flags & UWM_KRETPROBE_HANDLER))
 		return 0;

 	u->ret = test_unwind(NULL, (u->flags & UWM_REGS) ? regs : NULL,
 			     (u->flags & UWM_SP) ? u->sp : 0);

 	return 0;
 }

 static noinline notrace int test_unwind_kretprobed_func(struct unwindme *u)
 {
 	struct pt_regs regs;

 	if (!(u->flags & UWM_KRETPROBE))
 		return 0;

 	regs = fake_pt_regs();
 	return test_unwind(NULL, (u->flags & UWM_REGS) ? &regs : NULL,
 			   (u->flags & UWM_SP) ? u->sp : 0);
 }

 static noinline int test_unwind_kretprobed_func_caller(struct unwindme *u)
 {
 	return test_unwind_kretprobed_func(u);
 }

 static int test_unwind_kretprobe(struct unwindme *u)
 {
 	int ret;
 	struct kretprobe my_kretprobe;

 	if (!IS_ENABLED(CONFIG_KPROBES))
 		kunit_skip(current_test, "requires CONFIG_KPROBES");

 	u->ret = -1; /* make sure kprobe is called */
 	unwindme = u;

 	memset(&my_kretprobe, 0, sizeof(my_kretprobe));
 	my_kretprobe.handler = kretprobe_ret_handler;
 	my_kretprobe.maxactive = 1;
 	my_kretprobe.kp.addr = (kprobe_opcode_t *)test_unwind_kretprobed_func;

 	ret = register_kretprobe(&my_kretprobe);

 	if (ret < 0) {
 		kunit_err(current_test, "register_kretprobe failed %d\n", ret);
 		return -EINVAL;
 	}

 	ret = test_unwind_kretprobed_func_caller(u);
 	unregister_kretprobe(&my_kretprobe);
 	unwindme = NULL;
 	if (u->flags & UWM_KRETPROBE_HANDLER)
 		ret = u->ret;
 	return ret;
 }

 static int kprobe_pre_handler(struct kprobe *p, struct pt_regs *regs)
 {
 	struct unwindme *u = unwindme;

 	u->ret = test_unwind(NULL, (u->flags & UWM_REGS) ? regs : NULL,
 			     (u->flags & UWM_SP) ? u->sp : 0);
 	return 0;
 }

 extern const char test_unwind_kprobed_insn[];

 static noinline void test_unwind_kprobed_func(void)
 {
 	asm volatile(
 		"	nopr	%%r7\n"
 		"test_unwind_kprobed_insn:\n"
 		"	nopr	%%r7\n"
 		:);
 }

 static int test_unwind_kprobe(struct unwindme *u)
 {
 	struct kprobe kp;
 	int ret;

 	if (!IS_ENABLED(CONFIG_KPROBES))
 		kunit_skip(current_test, "requires CONFIG_KPROBES");
 	if (!IS_ENABLED(CONFIG_KPROBES_ON_FTRACE) && u->flags & UWM_KPROBE_ON_FTRACE)
 		kunit_skip(current_test, "requires CONFIG_KPROBES_ON_FTRACE");

 	u->ret = -1; /* make sure kprobe is called */
 	unwindme = u;
 	memset(&kp, 0, sizeof(kp));
 	kp.pre_handler = kprobe_pre_handler;
 	kp.addr = u->flags & UWM_KPROBE_ON_FTRACE ?
 				(kprobe_opcode_t *)test_unwind_kprobed_func :
 				(kprobe_opcode_t *)test_unwind_kprobed_insn;
 	ret = register_kprobe(&kp);
 	if (ret < 0) {
 		kunit_err(current_test, "register_kprobe failed %d\n", ret);
 		return -EINVAL;
 	}

 	test_unwind_kprobed_func();
 	unregister_kprobe(&kp);
 	unwindme = NULL;
 	return u->ret;
 }

 static void notrace __used test_unwind_ftrace_handler(unsigned long ip,
 						      unsigned long parent_ip,
 						      struct ftrace_ops *fops,
 						      struct ftrace_regs *fregs)
 {
 	struct unwindme *u = (struct unwindme *)fregs->regs.gprs[2];

 	u->ret = test_unwind(NULL, (u->flags & UWM_REGS) ? &fregs->regs : NULL,
 			     (u->flags & UWM_SP) ? u->sp : 0);
 }

 static noinline int test_unwind_ftraced_func(struct unwindme *u)
 {
 	return READ_ONCE(u)->ret;
 }

 static int test_unwind_ftrace(struct unwindme *u)
 {
 	int ret;
 #ifdef CONFIG_DYNAMIC_FTRACE
 	struct ftrace_ops *fops;

 	fops = kunit_kzalloc(current_test, sizeof(*fops), GFP_KERNEL);
 	fops->func = test_unwind_ftrace_handler;
 	fops->flags = FTRACE_OPS_FL_DYNAMIC |
 		     FTRACE_OPS_FL_RECURSION |
 		     FTRACE_OPS_FL_SAVE_REGS |
 		     FTRACE_OPS_FL_PERMANENT;
 #else
 	kunit_skip(current_test, "requires CONFIG_DYNAMIC_FTRACE");
 #endif

 	ret = ftrace_set_filter_ip(fops, (unsigned long)test_unwind_ftraced_func, 0, 0);
 	if (ret) {
 		kunit_err(current_test, "failed to set ftrace filter (%d)\n", ret);
 		return -1;
 	}

 	ret = register_ftrace_function(fops);
 	if (!ret) {
 		ret = test_unwind_ftraced_func(u);
 		unregister_ftrace_function(fops);
 	} else {
 		kunit_err(current_test, "failed to register ftrace handler (%d)\n", ret);
 	}

 	ftrace_set_filter_ip(fops, (unsigned long)test_unwind_ftraced_func, 1, 0);
 	return ret;
 }

 /* This function may or may not appear in the backtrace. */
 static noinline int unwindme_func4(struct unwindme *u)
 {
 	if (!(u->flags & UWM_CALLER))
 		u->sp = current_frame_address();
 	if (u->flags & UWM_THREAD) {
 		complete(&u->task_ready);
 		wait_event(u->task_wq, kthread_should_park());
 		kthread_parkme();
 		return 0;
 	} else if (u->flags & (UWM_PGM | UWM_KPROBE_ON_FTRACE)) {
 		return test_unwind_kprobe(u);
 	} else if (u->flags & (UWM_KRETPROBE | UWM_KRETPROBE_HANDLER)) {
 		return test_unwind_kretprobe(u);
 	} else if (u->flags & UWM_FTRACE) {
 		return test_unwind_ftrace(u);
 	} else {
 		struct pt_regs regs = fake_pt_regs();

 		return test_unwind(NULL,
 				   (u->flags & UWM_REGS) ? &regs : NULL,
 				   (u->flags & UWM_SP) ? u->sp : 0);
 	}
 }

 /* This function may or may not appear in the backtrace. */
 static noinline int unwindme_func3(struct unwindme *u)
 {
 	u->sp = current_frame_address();
 	return unwindme_func4(u);
 }

 /* This function must appear in the backtrace. */
 static noinline int unwindme_func2(struct unwindme *u)
 {
 	unsigned long flags;
 	int rc;

 	if (u->flags & UWM_SWITCH_STACK) {
 		local_irq_save(flags);
 		local_mcck_disable();
 		rc = call_on_stack(1, S390_lowcore.nodat_stack,
 				   int, unwindme_func3, struct unwindme *, u);
 		local_mcck_enable();
 		local_irq_restore(flags);
 		return rc;
 	} else {
 		return unwindme_func3(u);
 	}
 }

 /* This function must follow unwindme_func2 in the backtrace. */
 static noinline int unwindme_func1(void *u)
 {
 	return unwindme_func2((struct unwindme *)u);
 }

 static void unwindme_timer_fn(struct timer_list *unused)
 {
 	struct unwindme *u = READ_ONCE(unwindme);

 	if (u) {
 		unwindme = NULL;
 		u->task = NULL;
 		u->ret = unwindme_func1(u);
 		complete(&u->task_ready);
 	}
 }

 static struct timer_list unwind_timer;

 static int test_unwind_irq(struct unwindme *u)
 {
 	unwindme = u;
 	init_completion(&u->task_ready);
 	timer_setup(&unwind_timer, unwindme_timer_fn, 0);
 	mod_timer(&unwind_timer, jiffies + 1);
 	wait_for_completion(&u->task_ready);
 	return u->ret;
 }

 /* Spawns a task and passes it to test_unwind(). */
 static int test_unwind_task(struct unwindme *u)
 {
 	struct task_struct *task;
 	int ret;

 	/* Initialize thread-related fields. */
 	init_completion(&u->task_ready);
 	init_waitqueue_head(&u->task_wq);

 	/*
 	 * Start the task and wait until it reaches unwindme_func4() and sleeps
 	 * in (task_ready, unwind_done] range.
 	 */
 	task = kthread_run(unwindme_func1, u, "%s", __func__);
 	if (IS_ERR(task)) {
 		kunit_err(current_test, "kthread_run() failed\n");
 		return PTR_ERR(task);
 	}
 	/*
 	 * Make sure task reaches unwindme_func4 before parking it,
 	 * we might park it before kthread function has been executed otherwise
 	 */
 	wait_for_completion(&u->task_ready);
 	kthread_park(task);
 	/* Unwind. */
 	ret = test_unwind(task, NULL, (u->flags & UWM_SP) ? u->sp : 0);
 	kthread_stop(task);
 	return ret;
 }

 struct test_params {
 	int flags;
 	char *name;
 };

 /*
  * Create required parameter list for tests
  */
 #define TEST_WITH_FLAGS(f) { .flags = f, .name = #f }
 static const struct test_params param_list[] = {
 	TEST_WITH_FLAGS(UWM_DEFAULT),
 	TEST_WITH_FLAGS(UWM_SP),
 	TEST_WITH_FLAGS(UWM_REGS),
 	TEST_WITH_FLAGS(UWM_SWITCH_STACK),
 	TEST_WITH_FLAGS(UWM_SP | UWM_REGS),
 	TEST_WITH_FLAGS(UWM_CALLER | UWM_SP),
 	TEST_WITH_FLAGS(UWM_CALLER | UWM_SP | UWM_REGS),
 	TEST_WITH_FLAGS(UWM_CALLER | UWM_SP | UWM_REGS | UWM_SWITCH_STACK),
 	TEST_WITH_FLAGS(UWM_THREAD),
 	TEST_WITH_FLAGS(UWM_THREAD | UWM_SP),
 	TEST_WITH_FLAGS(UWM_THREAD | UWM_CALLER | UWM_SP),
 	TEST_WITH_FLAGS(UWM_IRQ),
 	TEST_WITH_FLAGS(UWM_IRQ | UWM_SWITCH_STACK),
 	TEST_WITH_FLAGS(UWM_IRQ | UWM_SP),
 	TEST_WITH_FLAGS(UWM_IRQ | UWM_REGS),
 	TEST_WITH_FLAGS(UWM_IRQ | UWM_SP | UWM_REGS),
 	TEST_WITH_FLAGS(UWM_IRQ | UWM_CALLER | UWM_SP),
 	TEST_WITH_FLAGS(UWM_IRQ | UWM_CALLER | UWM_SP | UWM_REGS),
 	TEST_WITH_FLAGS(UWM_IRQ | UWM_CALLER | UWM_SP | UWM_REGS | UWM_SWITCH_STACK),
 	TEST_WITH_FLAGS(UWM_PGM),
 	TEST_WITH_FLAGS(UWM_PGM | UWM_SP),
 	TEST_WITH_FLAGS(UWM_PGM | UWM_REGS),
 	TEST_WITH_FLAGS(UWM_PGM | UWM_SP | UWM_REGS),
 	TEST_WITH_FLAGS(UWM_KPROBE_ON_FTRACE),
 	TEST_WITH_FLAGS(UWM_KPROBE_ON_FTRACE | UWM_SP),
 	TEST_WITH_FLAGS(UWM_KPROBE_ON_FTRACE | UWM_REGS),
 	TEST_WITH_FLAGS(UWM_KPROBE_ON_FTRACE | UWM_SP | UWM_REGS),
 	TEST_WITH_FLAGS(UWM_FTRACE),
 	TEST_WITH_FLAGS(UWM_FTRACE | UWM_SP),
 	TEST_WITH_FLAGS(UWM_FTRACE | UWM_REGS),
 	TEST_WITH_FLAGS(UWM_FTRACE | UWM_SP | UWM_REGS),
 	TEST_WITH_FLAGS(UWM_KRETPROBE),
 	TEST_WITH_FLAGS(UWM_KRETPROBE | UWM_SP),
 	TEST_WITH_FLAGS(UWM_KRETPROBE | UWM_REGS),
 	TEST_WITH_FLAGS(UWM_KRETPROBE | UWM_SP | UWM_REGS),
 	TEST_WITH_FLAGS(UWM_KRETPROBE_HANDLER),
 	TEST_WITH_FLAGS(UWM_KRETPROBE_HANDLER | UWM_SP),
 	TEST_WITH_FLAGS(UWM_KRETPROBE_HANDLER | UWM_REGS),
 	TEST_WITH_FLAGS(UWM_KRETPROBE_HANDLER | UWM_SP | UWM_REGS),
 };

 /*
  * Parameter description generator: required for KUNIT_ARRAY_PARAM()
  */
 static void get_desc(const struct test_params *params, char *desc)
 {
 	strscpy(desc, params->name, KUNIT_PARAM_DESC_SIZE);
 }

 /*
  * Create test_unwind_gen_params
  */
 KUNIT_ARRAY_PARAM(test_unwind, param_list, get_desc);

 static void test_unwind_flags(struct kunit *test)
 {
 	struct unwindme u;
 	const struct test_params *params;

 	current_test = test;
 	params = (const struct test_params *)test->param_value;
 	u.flags = params->flags;
 	if (u.flags & UWM_THREAD)
 		KUNIT_EXPECT_EQ(test, 0, test_unwind_task(&u));
 	else if (u.flags & UWM_IRQ)
 		KUNIT_EXPECT_EQ(test, 0, test_unwind_irq(&u));
 	else
 		KUNIT_EXPECT_EQ(test, 0, unwindme_func1(&u));
 }

 static struct kunit_case unwind_test_cases[] = {
 	KUNIT_CASE_PARAM(test_unwind_flags, test_unwind_gen_params),
 	{}
 };

 static struct kunit_suite test_unwind_suite = {
 	.name = "test_unwind",
 	.test_cases = unwind_test_cases,
 };

 kunit_test_suites(&test_unwind_suite);

 MODULE_LICENSE("GPL");
	// SPDX-License-Identifier: GPL-2.0-only
	/*
	* Test module for unwind_for_each_frame
	*/

	#include <kunit/test.h>
	#include <asm/unwind.h>
	#include <linux/completion.h>
	#include <linux/kallsyms.h>
	#include <linux/kthread.h>
	#include <linux/ftrace.h>
	#include <linux/module.h>
	#include <linux/timer.h>
	#include <linux/slab.h>
	#include <linux/string.h>
	#include <linux/kprobes.h>
	#include <linux/wait.h>
	#include <asm/irq.h>

	static struct kunit *current_test;

	#define BT_BUF_SIZE (PAGE_SIZE * 4)

	static bool force_bt;
	module_param_named(backtrace, force_bt, bool, 0444);
	MODULE_PARM_DESC(backtrace, "print backtraces for all tests");

	/*
	* To avoid printk line limit split backtrace by lines
	*/
	static void print_backtrace(char *bt)
	{
	char *p;

	while (true) {
	p = strsep(&bt, "\n");
	if (!p)
	break;
	kunit_err(current_test, "%s\n", p);
	}
	}

	/*
	* Calls unwind_for_each_frame(task, regs, sp) and verifies that the result
	* contains unwindme_func2 followed by unwindme_func1.
	*/
	static noinline int test_unwind(struct task_struct task, struct pt_regs regs,
	unsigned long sp)
	{
	int frame_count, prev_is_func2, seen_func2_func1, seen_kretprobe_trampoline;
	const int max_frames = 128;
	struct unwind_state state;
	size_t bt_pos = 0;
	int ret = 0;
	char *bt;

	bt = kmalloc(BT_BUF_SIZE, GFP_ATOMIC);
	if (!bt) {
	kunit_err(current_test, "failed to allocate backtrace buffer\n");
	return -ENOMEM;
	}
	/* Unwind. */
	frame_count = 0;
	prev_is_func2 = 0;
	seen_func2_func1 = 0;
	seen_kretprobe_trampoline = 0;
	unwind_for_each_frame(&state, task, regs, sp) {
	unsigned long addr = unwind_get_return_address(&state);
	char sym[KSYM_SYMBOL_LEN];

	if (frame_count++ == max_frames)
	break;
	if (state.reliable && !addr) {
	kunit_err(current_test, "unwind state reliable but addr is 0\n");
	ret = -EINVAL;
	break;
	}
	sprint_symbol(sym, addr);
	if (bt_pos < BT_BUF_SIZE) {
	bt_pos += snprintf(bt + bt_pos, BT_BUF_SIZE - bt_pos,
	state.reliable ? " [%-7s%px] %pSR\n" :
	"([%-7s%px] %pSR)\n",
	stack_type_name(state.stack_info.type),
	(void )state.sp, (void )state.ip);
	if (bt_pos >= BT_BUF_SIZE)
	kunit_err(current_test, "backtrace buffer is too small\n");
	}
	frame_count += 1;
	if (prev_is_func2 && str_has_prefix(sym, "unwindme_func1"))
	seen_func2_func1 = 1;
	prev_is_func2 = str_has_prefix(sym, "unwindme_func2");
	if (str_has_prefix(sym, "__kretprobe_trampoline+0x0/"))
	seen_kretprobe_trampoline = 1;
	}

	/* Check the results. */
	if (unwind_error(&state)) {
	kunit_err(current_test, "unwind error\n");
	ret = -EINVAL;
	}
	if (!seen_func2_func1) {
	kunit_err(current_test, "unwindme_func2 and unwindme_func1 not found\n");
	ret = -EINVAL;
	}
	if (frame_count == max_frames) {
	kunit_err(current_test, "Maximum number of frames exceeded\n");
	ret = -EINVAL;
	}
	if (seen_kretprobe_trampoline) {
	kunit_err(current_test, "__kretprobe_trampoline+0x0 in unwinding results\n");
	ret = -EINVAL;
	}
	if (ret \|\| force_bt)
	print_backtrace(bt);
	kfree(bt);
	return ret;
	}

	/* State of the task being unwound. */
	struct unwindme {
	int flags;
	int ret;
	struct task_struct *task;
	struct completion task_ready;
	wait_queue_head_t task_wq;
	unsigned long sp;
	};

	static struct unwindme *unwindme;

	/* Values of unwindme.flags. */
	#define UWM_DEFAULT 0x0
	#define UWM_THREAD 0x1 /* Unwind a separate task. */
	#define UWM_REGS 0x2 /* Pass regs to test_unwind(). */
	#define UWM_SP 0x4 /* Pass sp to test_unwind(). */
	#define UWM_CALLER 0x8 /* Unwind starting from caller. */
	#define UWM_SWITCH_STACK 0x10 /* Use call_on_stack. */
	#define UWM_IRQ 0x20 /* Unwind from irq context. */
	#define UWM_PGM 0x40 /* Unwind from program check handler */
	#define UWM_KPROBE_ON_FTRACE 0x80 /* Unwind from kprobe handler called via ftrace. */
	#define UWM_FTRACE 0x100 /* Unwind from ftrace handler. */
	#define UWM_KRETPROBE 0x200 /* Unwind through kretprobed function. */
	#define UWM_KRETPROBE_HANDLER 0x400 /* Unwind from kretprobe handler. */

	static __always_inline struct pt_regs fake_pt_regs(void)
	{
	struct pt_regs regs;

	memset(&regs, 0, sizeof(regs));
	regs.gprs[15] = current_stack_pointer;

	asm volatile(
	"basr %[psw_addr],0\n"
	: [psw_addr] "=d" (regs.psw.addr));
	return regs;
	}

	static int kretprobe_ret_handler(struct kretprobe_instance ri, struct pt_regs regs)
	{
	struct unwindme *u = unwindme;

	if (!(u->flags & UWM_KRETPROBE_HANDLER))
	return 0;

	u->ret = test_unwind(NULL, (u->flags & UWM_REGS) ? regs : NULL,
	(u->flags & UWM_SP) ? u->sp : 0);

	return 0;
	}

	static noinline notrace int test_unwind_kretprobed_func(struct unwindme *u)
	{
	struct pt_regs regs;

	if (!(u->flags & UWM_KRETPROBE))
	return 0;

	regs = fake_pt_regs();
	return test_unwind(NULL, (u->flags & UWM_REGS) ? &regs : NULL,
	(u->flags & UWM_SP) ? u->sp : 0);
	}

	static noinline int test_unwind_kretprobed_func_caller(struct unwindme *u)
	{
	return test_unwind_kretprobed_func(u);
	}

	static int test_unwind_kretprobe(struct unwindme *u)
	{
	int ret;
	struct kretprobe my_kretprobe;

	if (!IS_ENABLED(CONFIG_KPROBES))
	kunit_skip(current_test, "requires CONFIG_KPROBES");

	u->ret = -1; /* make sure kprobe is called */
	unwindme = u;

	memset(&my_kretprobe, 0, sizeof(my_kretprobe));
	my_kretprobe.handler = kretprobe_ret_handler;
	my_kretprobe.maxactive = 1;
	my_kretprobe.kp.addr = (kprobe_opcode_t *)test_unwind_kretprobed_func;

	ret = register_kretprobe(&my_kretprobe);

	if (ret < 0) {
	kunit_err(current_test, "register_kretprobe failed %d\n", ret);
	return -EINVAL;
	}

	ret = test_unwind_kretprobed_func_caller(u);
	unregister_kretprobe(&my_kretprobe);
	unwindme = NULL;
	if (u->flags & UWM_KRETPROBE_HANDLER)
	ret = u->ret;
	return ret;
	}

	static int kprobe_pre_handler(struct kprobe p, struct pt_regs regs)
	{
	struct unwindme *u = unwindme;

	u->ret = test_unwind(NULL, (u->flags & UWM_REGS) ? regs : NULL,
	(u->flags & UWM_SP) ? u->sp : 0);
	return 0;
	}

	extern const char test_unwind_kprobed_insn[];

	static noinline void test_unwind_kprobed_func(void)
	{
	asm volatile(
	" nopr %%r7\n"
	"test_unwind_kprobed_insn:\n"
	" nopr %%r7\n"
	:);
	}

	static int test_unwind_kprobe(struct unwindme *u)
	{
	struct kprobe kp;
	int ret;

	if (!IS_ENABLED(CONFIG_KPROBES))
	kunit_skip(current_test, "requires CONFIG_KPROBES");
	if (!IS_ENABLED(CONFIG_KPROBES_ON_FTRACE) && u->flags & UWM_KPROBE_ON_FTRACE)
	kunit_skip(current_test, "requires CONFIG_KPROBES_ON_FTRACE");

	u->ret = -1; /* make sure kprobe is called */
	unwindme = u;
	memset(&kp, 0, sizeof(kp));
	kp.pre_handler = kprobe_pre_handler;
	kp.addr = u->flags & UWM_KPROBE_ON_FTRACE ?
	(kprobe_opcode_t *)test_unwind_kprobed_func :
	(kprobe_opcode_t *)test_unwind_kprobed_insn;
	ret = register_kprobe(&kp);
	if (ret < 0) {
	kunit_err(current_test, "register_kprobe failed %d\n", ret);
	return -EINVAL;
	}

	test_unwind_kprobed_func();
	unregister_kprobe(&kp);
	unwindme = NULL;
	return u->ret;
	}

	static void notrace __used test_unwind_ftrace_handler(unsigned long ip,
	unsigned long parent_ip,
	struct ftrace_ops *fops,
	struct ftrace_regs *fregs)
	{
	struct unwindme u = (struct unwindme )fregs->regs.gprs[2];

	u->ret = test_unwind(NULL, (u->flags & UWM_REGS) ? &fregs->regs : NULL,
	(u->flags & UWM_SP) ? u->sp : 0);
	}

	static noinline int test_unwind_ftraced_func(struct unwindme *u)
	{
	return READ_ONCE(u)->ret;
	}

	static int test_unwind_ftrace(struct unwindme *u)
	{
	int ret;
	#ifdef CONFIG_DYNAMIC_FTRACE
	struct ftrace_ops *fops;

	fops = kunit_kzalloc(current_test, sizeof(*fops), GFP_KERNEL);
	fops->func = test_unwind_ftrace_handler;
	fops->flags = FTRACE_OPS_FL_DYNAMIC \|
	FTRACE_OPS_FL_RECURSION \|
	FTRACE_OPS_FL_SAVE_REGS \|
	FTRACE_OPS_FL_PERMANENT;
	#else
	kunit_skip(current_test, "requires CONFIG_DYNAMIC_FTRACE");
	#endif

	ret = ftrace_set_filter_ip(fops, (unsigned long)test_unwind_ftraced_func, 0, 0);
	if (ret) {
	kunit_err(current_test, "failed to set ftrace filter (%d)\n", ret);
	return -1;
	}

	ret = register_ftrace_function(fops);
	if (!ret) {
	ret = test_unwind_ftraced_func(u);
	unregister_ftrace_function(fops);
	} else {
	kunit_err(current_test, "failed to register ftrace handler (%d)\n", ret);
	}

	ftrace_set_filter_ip(fops, (unsigned long)test_unwind_ftraced_func, 1, 0);
	return ret;
	}

	/* This function may or may not appear in the backtrace. */
	static noinline int unwindme_func4(struct unwindme *u)
	{
	if (!(u->flags & UWM_CALLER))
	u->sp = current_frame_address();
	if (u->flags & UWM_THREAD) {
	complete(&u->task_ready);
	wait_event(u->task_wq, kthread_should_park());
	kthread_parkme();
	return 0;
	} else if (u->flags & (UWM_PGM \| UWM_KPROBE_ON_FTRACE)) {
	return test_unwind_kprobe(u);
	} else if (u->flags & (UWM_KRETPROBE \| UWM_KRETPROBE_HANDLER)) {
	return test_unwind_kretprobe(u);
	} else if (u->flags & UWM_FTRACE) {
	return test_unwind_ftrace(u);
	} else {
	struct pt_regs regs = fake_pt_regs();

	return test_unwind(NULL,
	(u->flags & UWM_REGS) ? &regs : NULL,
	(u->flags & UWM_SP) ? u->sp : 0);
	}
	}

	/* This function may or may not appear in the backtrace. */
	static noinline int unwindme_func3(struct unwindme *u)
	{
	u->sp = current_frame_address();
	return unwindme_func4(u);
	}

	/* This function must appear in the backtrace. */
	static noinline int unwindme_func2(struct unwindme *u)
	{
	unsigned long flags;
	int rc;

	if (u->flags & UWM_SWITCH_STACK) {
	local_irq_save(flags);
	local_mcck_disable();
	rc = call_on_stack(1, S390_lowcore.nodat_stack,
	int, unwindme_func3, struct unwindme *, u);
	local_mcck_enable();
	local_irq_restore(flags);
	return rc;
	} else {
	return unwindme_func3(u);
	}
	}

	/* This function must follow unwindme_func2 in the backtrace. */
	static noinline int unwindme_func1(void *u)
	{
	return unwindme_func2((struct unwindme *)u);
	}

	static void unwindme_timer_fn(struct timer_list *unused)
	{
	struct unwindme *u = READ_ONCE(unwindme);

	if (u) {
	unwindme = NULL;
	u->task = NULL;
	u->ret = unwindme_func1(u);
	complete(&u->task_ready);
	}
	}

	static struct timer_list unwind_timer;

	static int test_unwind_irq(struct unwindme *u)
	{
	unwindme = u;
	init_completion(&u->task_ready);
	timer_setup(&unwind_timer, unwindme_timer_fn, 0);
	mod_timer(&unwind_timer, jiffies + 1);
	wait_for_completion(&u->task_ready);
	return u->ret;
	}

	/* Spawns a task and passes it to test_unwind(). */
	static int test_unwind_task(struct unwindme *u)
	{
	struct task_struct *task;
	int ret;

	/* Initialize thread-related fields. */
	init_completion(&u->task_ready);
	init_waitqueue_head(&u->task_wq);

	/*
	* Start the task and wait until it reaches unwindme_func4() and sleeps
	* in (task_ready, unwind_done] range.
	*/
	task = kthread_run(unwindme_func1, u, "%s", __func__);
	if (IS_ERR(task)) {
	kunit_err(current_test, "kthread_run() failed\n");
	return PTR_ERR(task);
	}
	/*
	* Make sure task reaches unwindme_func4 before parking it,
	* we might park it before kthread function has been executed otherwise
	*/
	wait_for_completion(&u->task_ready);
	kthread_park(task);
	/* Unwind. */
	ret = test_unwind(task, NULL, (u->flags & UWM_SP) ? u->sp : 0);
	kthread_stop(task);
	return ret;
	}

	struct test_params {
	int flags;
	char *name;
	};

	/*
	* Create required parameter list for tests
	*/
	#define TEST_WITH_FLAGS(f) { .flags = f, .name = #f }
	static const struct test_params param_list[] = {
	TEST_WITH_FLAGS(UWM_DEFAULT),
	TEST_WITH_FLAGS(UWM_SP),
	TEST_WITH_FLAGS(UWM_REGS),
	TEST_WITH_FLAGS(UWM_SWITCH_STACK),
	TEST_WITH_FLAGS(UWM_SP \| UWM_REGS),
	TEST_WITH_FLAGS(UWM_CALLER \| UWM_SP),
	TEST_WITH_FLAGS(UWM_CALLER \| UWM_SP \| UWM_REGS),
	TEST_WITH_FLAGS(UWM_CALLER \| UWM_SP \| UWM_REGS \| UWM_SWITCH_STACK),
	TEST_WITH_FLAGS(UWM_THREAD),
	TEST_WITH_FLAGS(UWM_THREAD \| UWM_SP),
	TEST_WITH_FLAGS(UWM_THREAD \| UWM_CALLER \| UWM_SP),
	TEST_WITH_FLAGS(UWM_IRQ),
	TEST_WITH_FLAGS(UWM_IRQ \| UWM_SWITCH_STACK),
	TEST_WITH_FLAGS(UWM_IRQ \| UWM_SP),
	TEST_WITH_FLAGS(UWM_IRQ \| UWM_REGS),
	TEST_WITH_FLAGS(UWM_IRQ \| UWM_SP \| UWM_REGS),
	TEST_WITH_FLAGS(UWM_IRQ \| UWM_CALLER \| UWM_SP),
	TEST_WITH_FLAGS(UWM_IRQ \| UWM_CALLER \| UWM_SP \| UWM_REGS),
	TEST_WITH_FLAGS(UWM_IRQ \| UWM_CALLER \| UWM_SP \| UWM_REGS \| UWM_SWITCH_STACK),
	TEST_WITH_FLAGS(UWM_PGM),
	TEST_WITH_FLAGS(UWM_PGM \| UWM_SP),
	TEST_WITH_FLAGS(UWM_PGM \| UWM_REGS),
	TEST_WITH_FLAGS(UWM_PGM \| UWM_SP \| UWM_REGS),
	TEST_WITH_FLAGS(UWM_KPROBE_ON_FTRACE),
	TEST_WITH_FLAGS(UWM_KPROBE_ON_FTRACE \| UWM_SP),
	TEST_WITH_FLAGS(UWM_KPROBE_ON_FTRACE \| UWM_REGS),
	TEST_WITH_FLAGS(UWM_KPROBE_ON_FTRACE \| UWM_SP \| UWM_REGS),
	TEST_WITH_FLAGS(UWM_FTRACE),
	TEST_WITH_FLAGS(UWM_FTRACE \| UWM_SP),
	TEST_WITH_FLAGS(UWM_FTRACE \| UWM_REGS),
	TEST_WITH_FLAGS(UWM_FTRACE \| UWM_SP \| UWM_REGS),
	TEST_WITH_FLAGS(UWM_KRETPROBE),
	TEST_WITH_FLAGS(UWM_KRETPROBE \| UWM_SP),
	TEST_WITH_FLAGS(UWM_KRETPROBE \| UWM_REGS),
	TEST_WITH_FLAGS(UWM_KRETPROBE \| UWM_SP \| UWM_REGS),
	TEST_WITH_FLAGS(UWM_KRETPROBE_HANDLER),
	TEST_WITH_FLAGS(UWM_KRETPROBE_HANDLER \| UWM_SP),
	TEST_WITH_FLAGS(UWM_KRETPROBE_HANDLER \| UWM_REGS),
	TEST_WITH_FLAGS(UWM_KRETPROBE_HANDLER \| UWM_SP \| UWM_REGS),
	};

	/*
	* Parameter description generator: required for KUNIT_ARRAY_PARAM()
	*/
	static void get_desc(const struct test_params params, char desc)
	{
	strscpy(desc, params->name, KUNIT_PARAM_DESC_SIZE);
	}

	/*
	* Create test_unwind_gen_params
	*/
	KUNIT_ARRAY_PARAM(test_unwind, param_list, get_desc);

	static void test_unwind_flags(struct kunit *test)
	{
	struct unwindme u;
	const struct test_params *params;

	current_test = test;
	params = (const struct test_params *)test->param_value;
	u.flags = params->flags;
	if (u.flags & UWM_THREAD)
	KUNIT_EXPECT_EQ(test, 0, test_unwind_task(&u));
	else if (u.flags & UWM_IRQ)
	KUNIT_EXPECT_EQ(test, 0, test_unwind_irq(&u));
	else
	KUNIT_EXPECT_EQ(test, 0, unwindme_func1(&u));
	}

	static struct kunit_case unwind_test_cases[] = {
	KUNIT_CASE_PARAM(test_unwind_flags, test_unwind_gen_params),
	{}
	};

	static struct kunit_suite test_unwind_suite = {
	.name = "test_unwind",
	.test_cases = unwind_test_cases,
	};

	kunit_test_suites(&test_unwind_suite);

	MODULE_LICENSE("GPL");