[linux.git] / lib / test_fprobe.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * test_fprobe.c - simple sanity test for fprobe
 */

#include <linux/kernel.h>
#include <linux/fprobe.h>
#include <linux/random.h>
#include <kunit/test.h>

#define div_factor 3

static struct kunit *current_test;

static u32 rand1, entry_val, exit_val;

/* Use indirect calls to avoid inlining the target functions */
static u32 (*target)(u32 value);
static u32 (*target2)(u32 value);
static u32 (*target_nest)(u32 value, u32 (*nest)(u32));
static unsigned long target_ip;
static unsigned long target2_ip;
static unsigned long target_nest_ip;

static noinline u32 fprobe_selftest_target(u32 value)
{
	return (value / div_factor);
}

static noinline u32 fprobe_selftest_target2(u32 value)
{
	return (value / div_factor) + 1;
}

static noinline u32 fprobe_selftest_nest_target(u32 value, u32 (*nest)(u32))
{
	return nest(value + 2);
}

static notrace int fp_entry_handler(struct fprobe *fp, unsigned long ip,
				     struct pt_regs *regs, void *data)
{
	KUNIT_EXPECT_FALSE(current_test, preemptible());
	/* This can be called on the fprobe_selftest_target and the fprobe_selftest_target2 */
	if (ip != target_ip)
		KUNIT_EXPECT_EQ(current_test, ip, target2_ip);
	entry_val = (rand1 / div_factor);
	if (fp->entry_data_size) {
		KUNIT_EXPECT_NOT_NULL(current_test, data);
		if (data)
			*(u32 *)data = entry_val;
	} else
		KUNIT_EXPECT_NULL(current_test, data);

	return 0;
}

static notrace void fp_exit_handler(struct fprobe *fp, unsigned long ip,
				    struct pt_regs *regs, void *data)
{
	unsigned long ret = regs_return_value(regs);

	KUNIT_EXPECT_FALSE(current_test, preemptible());
	if (ip != target_ip) {
		KUNIT_EXPECT_EQ(current_test, ip, target2_ip);
		KUNIT_EXPECT_EQ(current_test, ret, (rand1 / div_factor) + 1);
	} else
		KUNIT_EXPECT_EQ(current_test, ret, (rand1 / div_factor));
	KUNIT_EXPECT_EQ(current_test, entry_val, (rand1 / div_factor));
	exit_val = entry_val + div_factor;
	if (fp->entry_data_size) {
		KUNIT_EXPECT_NOT_NULL(current_test, data);
		if (data)
			KUNIT_EXPECT_EQ(current_test, *(u32 *)data, entry_val);
	} else
		KUNIT_EXPECT_NULL(current_test, data);
}

static notrace int nest_entry_handler(struct fprobe *fp, unsigned long ip,
				     struct pt_regs *regs, void *data)
{
	KUNIT_EXPECT_FALSE(current_test, preemptible());
	return 0;
}

static notrace void nest_exit_handler(struct fprobe *fp, unsigned long ip,
				    struct pt_regs *regs, void *data)
{
	KUNIT_EXPECT_FALSE(current_test, preemptible());
	KUNIT_EXPECT_EQ(current_test, ip, target_nest_ip);
}

/* Test entry only (no rethook) */
static void test_fprobe_entry(struct kunit *test)
{
	struct fprobe fp_entry = {
		.entry_handler = fp_entry_handler,
	};

	current_test = test;

	/* Before register, unregister should be failed. */
	KUNIT_EXPECT_NE(test, 0, unregister_fprobe(&fp_entry));
	KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp_entry, "fprobe_selftest_target*", NULL));

	entry_val = 0;
	exit_val = 0;
	target(rand1);
	KUNIT_EXPECT_NE(test, 0, entry_val);
	KUNIT_EXPECT_EQ(test, 0, exit_val);

	entry_val = 0;
	exit_val = 0;
	target2(rand1);
	KUNIT_EXPECT_NE(test, 0, entry_val);
	KUNIT_EXPECT_EQ(test, 0, exit_val);

	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp_entry));
}

static void test_fprobe(struct kunit *test)
{
	struct fprobe fp = {
		.entry_handler = fp_entry_handler,
		.exit_handler = fp_exit_handler,
	};

	current_test = test;
	KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp, "fprobe_selftest_target*", NULL));

	entry_val = 0;
	exit_val = 0;
	target(rand1);
	KUNIT_EXPECT_NE(test, 0, entry_val);
	KUNIT_EXPECT_EQ(test, entry_val + div_factor, exit_val);

	entry_val = 0;
	exit_val = 0;
	target2(rand1);
	KUNIT_EXPECT_NE(test, 0, entry_val);
	KUNIT_EXPECT_EQ(test, entry_val + div_factor, exit_val);

	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
}

static void test_fprobe_syms(struct kunit *test)
{
	static const char *syms[] = {"fprobe_selftest_target", "fprobe_selftest_target2"};
	struct fprobe fp = {
		.entry_handler = fp_entry_handler,
		.exit_handler = fp_exit_handler,
	};

	current_test = test;
	KUNIT_EXPECT_EQ(test, 0, register_fprobe_syms(&fp, syms, 2));

	entry_val = 0;
	exit_val = 0;
	target(rand1);
	KUNIT_EXPECT_NE(test, 0, entry_val);
	KUNIT_EXPECT_EQ(test, entry_val + div_factor, exit_val);

	entry_val = 0;
	exit_val = 0;
	target2(rand1);
	KUNIT_EXPECT_NE(test, 0, entry_val);
	KUNIT_EXPECT_EQ(test, entry_val + div_factor, exit_val);

	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
}

/* Test private entry_data */
static void test_fprobe_data(struct kunit *test)
{
	struct fprobe fp = {
		.entry_handler = fp_entry_handler,
		.exit_handler = fp_exit_handler,
		.entry_data_size = sizeof(u32),
	};

	current_test = test;
	KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp, "fprobe_selftest_target", NULL));

	target(rand1);

	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
}

/* Test nr_maxactive */
static void test_fprobe_nest(struct kunit *test)
{
	static const char *syms[] = {"fprobe_selftest_target", "fprobe_selftest_nest_target"};
	struct fprobe fp = {
		.entry_handler = nest_entry_handler,
		.exit_handler = nest_exit_handler,
		.nr_maxactive = 1,
	};

	current_test = test;
	KUNIT_EXPECT_EQ(test, 0, register_fprobe_syms(&fp, syms, 2));

	target_nest(rand1, target);
	KUNIT_EXPECT_EQ(test, 1, fp.nmissed);

	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
}

static unsigned long get_ftrace_location(void *func)
{
	unsigned long size, addr = (unsigned long)func;

	if (!kallsyms_lookup_size_offset(addr, &size, NULL) || !size)
		return 0;

	return ftrace_location_range(addr, addr + size - 1);
}

static int fprobe_test_init(struct kunit *test)
{
	rand1 = get_random_u32_above(div_factor);
	target = fprobe_selftest_target;
	target2 = fprobe_selftest_target2;
	target_nest = fprobe_selftest_nest_target;
	target_ip = get_ftrace_location(target);
	target2_ip = get_ftrace_location(target2);
	target_nest_ip = get_ftrace_location(target_nest);

	return 0;
}

static struct kunit_case fprobe_testcases[] = {
	KUNIT_CASE(test_fprobe_entry),
	KUNIT_CASE(test_fprobe),
	KUNIT_CASE(test_fprobe_syms),
	KUNIT_CASE(test_fprobe_data),
	KUNIT_CASE(test_fprobe_nest),
	{}
};

static struct kunit_suite fprobe_test_suite = {
	.name = "fprobe_test",
	.init = fprobe_test_init,
	.test_cases = fprobe_testcases,
};

kunit_test_suites(&fprobe_test_suite);

MODULE_LICENSE("GPL");
Commit	Line	Data
f4616fab MH	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/*
	3	* test_fprobe.c - simple sanity test for fprobe
	4	*/
	5
	6	#include <linux/kernel.h>
	7	#include <linux/fprobe.h>
	8	#include <linux/random.h>
	9	#include <kunit/test.h>
	10
	11	#define div_factor 3
	12
	13	static struct kunit *current_test;
	14
	15	static u32 rand1, entry_val, exit_val;
	16
	17	/* Use indirect calls to avoid inlining the target functions */
	18	static u32 (*target)(u32 value);
	19	static u32 (*target2)(u32 value);
7e7ef1bf	20	static u32 (target_nest)(u32 value, u32 (nest)(u32));
f4616fab MH	21	static unsigned long target_ip;
f4616fab MH	22	static unsigned long target2_ip;
7e7ef1bf	23	static unsigned long target_nest_ip;
f4616fab MH	24
	25	static noinline u32 fprobe_selftest_target(u32 value)
	26	{
	27	return (value / div_factor);
	28	}
	29
	30	static noinline u32 fprobe_selftest_target2(u32 value)
	31	{
	32	return (value / div_factor) + 1;
	33	}
	34
7e7ef1bf MHG	35	static noinline u32 fprobe_selftest_nest_target(u32 value, u32 (*nest)(u32))
	36	{
	37	return nest(value + 2);
	38	}
	39
39d95420	40	static notrace int fp_entry_handler(struct fprobe *fp, unsigned long ip,
76d0de57	41	struct pt_regs regs, void data)
f4616fab MH	42	{
	43	KUNIT_EXPECT_FALSE(current_test, preemptible());
	44	/* This can be called on the fprobe_selftest_target and the fprobe_selftest_target2 */
	45	if (ip != target_ip)
	46	KUNIT_EXPECT_EQ(current_test, ip, target2_ip);
	47	entry_val = (rand1 / div_factor);
34cabf8f MHG	48	if (fp->entry_data_size) {
	49	KUNIT_EXPECT_NOT_NULL(current_test, data);
	50	if (data)
	51	(u32 )data = entry_val;
	52	} else
	53	KUNIT_EXPECT_NULL(current_test, data);
39d95420 MHG	54
39d95420 MHG	55	return 0;
f4616fab MH	56	}
f4616fab MH	57
76d0de57 MHG	58	static notrace void fp_exit_handler(struct fprobe *fp, unsigned long ip,
76d0de57 MHG	59	struct pt_regs regs, void data)
f4616fab MH	60	{
	61	unsigned long ret = regs_return_value(regs);
	62
	63	KUNIT_EXPECT_FALSE(current_test, preemptible());
	64	if (ip != target_ip) {
	65	KUNIT_EXPECT_EQ(current_test, ip, target2_ip);
	66	KUNIT_EXPECT_EQ(current_test, ret, (rand1 / div_factor) + 1);
	67	} else
	68	KUNIT_EXPECT_EQ(current_test, ret, (rand1 / div_factor));
	69	KUNIT_EXPECT_EQ(current_test, entry_val, (rand1 / div_factor));
	70	exit_val = entry_val + div_factor;
34cabf8f MHG	71	if (fp->entry_data_size) {
	72	KUNIT_EXPECT_NOT_NULL(current_test, data);
	73	if (data)
	74	KUNIT_EXPECT_EQ(current_test, (u32 )data, entry_val);
	75	} else
	76	KUNIT_EXPECT_NULL(current_test, data);
f4616fab MH	77	}
f4616fab MH	78
39d95420	79	static notrace int nest_entry_handler(struct fprobe *fp, unsigned long ip,
7e7ef1bf MHG	80	struct pt_regs regs, void data)
	81	{
	82	KUNIT_EXPECT_FALSE(current_test, preemptible());
39d95420	83	return 0;
7e7ef1bf MHG	84	}
	85
	86	static notrace void nest_exit_handler(struct fprobe *fp, unsigned long ip,
	87	struct pt_regs regs, void data)
	88	{
	89	KUNIT_EXPECT_FALSE(current_test, preemptible());
	90	KUNIT_EXPECT_EQ(current_test, ip, target_nest_ip);
	91	}
	92
f4616fab MH	93	/* Test entry only (no rethook) */
	94	static void test_fprobe_entry(struct kunit *test)
	95	{
	96	struct fprobe fp_entry = {
	97	.entry_handler = fp_entry_handler,
	98	};
	99
	100	current_test = test;
	101
	102	/* Before register, unregister should be failed. */
	103	KUNIT_EXPECT_NE(test, 0, unregister_fprobe(&fp_entry));
	104	KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp_entry, "fprobe_selftest_target*", NULL));
	105
	106	entry_val = 0;
	107	exit_val = 0;
	108	target(rand1);
	109	KUNIT_EXPECT_NE(test, 0, entry_val);
	110	KUNIT_EXPECT_EQ(test, 0, exit_val);
	111
	112	entry_val = 0;
	113	exit_val = 0;
	114	target2(rand1);
	115	KUNIT_EXPECT_NE(test, 0, entry_val);
	116	KUNIT_EXPECT_EQ(test, 0, exit_val);
	117
	118	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp_entry));
	119	}
	120
	121	static void test_fprobe(struct kunit *test)
	122	{
	123	struct fprobe fp = {
	124	.entry_handler = fp_entry_handler,
	125	.exit_handler = fp_exit_handler,
	126	};
	127
	128	current_test = test;
	129	KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp, "fprobe_selftest_target*", NULL));
	130
	131	entry_val = 0;
	132	exit_val = 0;
	133	target(rand1);
	134	KUNIT_EXPECT_NE(test, 0, entry_val);
	135	KUNIT_EXPECT_EQ(test, entry_val + div_factor, exit_val);
	136
	137	entry_val = 0;
	138	exit_val = 0;
	139	target2(rand1);
	140	KUNIT_EXPECT_NE(test, 0, entry_val);
	141	KUNIT_EXPECT_EQ(test, entry_val + div_factor, exit_val);
	142
	143	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
	144	}
	145
	146	static void test_fprobe_syms(struct kunit *test)
	147	{
	148	static const char *syms[] = {"fprobe_selftest_target", "fprobe_selftest_target2"};
	149	struct fprobe fp = {
	150	.entry_handler = fp_entry_handler,
	151	.exit_handler = fp_exit_handler,
	152	};
	153
	154	current_test = test;
	155	KUNIT_EXPECT_EQ(test, 0, register_fprobe_syms(&fp, syms, 2));
	156
157	entry_val = 0;
158	exit_val = 0;
159	target(rand1);
160	KUNIT_EXPECT_NE(test, 0, entry_val);
161	KUNIT_EXPECT_EQ(test, entry_val + div_factor, exit_val);
162
163	entry_val = 0;
164	exit_val = 0;
165	target2(rand1);
166	KUNIT_EXPECT_NE(test, 0, entry_val);
167	KUNIT_EXPECT_EQ(test, entry_val + div_factor, exit_val);
168
169	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
170	}
171
34cabf8f MHG	172	/* Test private entry_data */
	173	static void test_fprobe_data(struct kunit *test)
	174	{
	175	struct fprobe fp = {
	176	.entry_handler = fp_entry_handler,
	177	.exit_handler = fp_exit_handler,
	178	.entry_data_size = sizeof(u32),
	179	};
	180
	181	current_test = test;
	182	KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp, "fprobe_selftest_target", NULL));
	183
	184	target(rand1);
	185
	186	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
	187	}
	188
7e7ef1bf MHG	189	/* Test nr_maxactive */
	190	static void test_fprobe_nest(struct kunit *test)
	191	{
	192	static const char *syms[] = {"fprobe_selftest_target", "fprobe_selftest_nest_target"};
	193	struct fprobe fp = {
	194	.entry_handler = nest_entry_handler,
	195	.exit_handler = nest_exit_handler,
	196	.nr_maxactive = 1,
	197	};
	198
	199	current_test = test;
	200	KUNIT_EXPECT_EQ(test, 0, register_fprobe_syms(&fp, syms, 2));
	201
	202	target_nest(rand1, target);
	203	KUNIT_EXPECT_EQ(test, 1, fp.nmissed);
	204
	205	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
	206	}
	207
f4616fab MH	208	static unsigned long get_ftrace_location(void *func)
	209	{
	210	unsigned long size, addr = (unsigned long)func;
	211
	212	if (!kallsyms_lookup_size_offset(addr, &size, NULL) \|\| !size)
	213	return 0;
	214
	215	return ftrace_location_range(addr, addr + size - 1);
	216	}
	217
	218	static int fprobe_test_init(struct kunit *test)
	219	{
d247aabd	220	rand1 = get_random_u32_above(div_factor);
f4616fab MH	221	target = fprobe_selftest_target;
f4616fab MH	222	target2 = fprobe_selftest_target2;
7e7ef1bf	223	target_nest = fprobe_selftest_nest_target;
f4616fab MH	224	target_ip = get_ftrace_location(target);
f4616fab MH	225	target2_ip = get_ftrace_location(target2);
7e7ef1bf	226	target_nest_ip = get_ftrace_location(target_nest);
f4616fab MH	227
	228	return 0;
	229	}
	230
	231	static struct kunit_case fprobe_testcases[] = {
	232	KUNIT_CASE(test_fprobe_entry),
	233	KUNIT_CASE(test_fprobe),
	234	KUNIT_CASE(test_fprobe_syms),
34cabf8f	235	KUNIT_CASE(test_fprobe_data),
7e7ef1bf	236	KUNIT_CASE(test_fprobe_nest),
f4616fab MH	237	{}
	238	};
	239
	240	static struct kunit_suite fprobe_test_suite = {
	241	.name = "fprobe_test",
	242	.init = fprobe_test_init,
	243	.test_cases = fprobe_testcases,
	244	};
	245
	246	kunit_test_suites(&fprobe_test_suite);
	247
	248	MODULE_LICENSE("GPL");