test_fprobe.c

  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
 13static struct kunit *current_test;
 14
 15static u32 rand1, entry_only_val, entry_val, exit_val;
 16static u32 entry_only_count, entry_count, exit_count;
 17
 18/* Use indirect calls to avoid inlining the target functions */
 19static u32 (*target)(u32 value);
 20static u32 (*target2)(u32 value);
 21static unsigned long target_ip;
 22static unsigned long target2_ip;
 23static int entry_return_value;
 24
 25static noinline u32 fprobe_selftest_target(u32 value)
 26{
 27	return (value / div_factor);
 28}
 29
 30static noinline u32 fprobe_selftest_target2(u32 value)
 31{
 32	return (value / div_factor) + 1;
 33}
 34
 35static notrace int fp_entry_handler(struct fprobe *fp, unsigned long ip,
 36				    unsigned long ret_ip,
 37				    struct ftrace_regs *fregs, void *data)
 38{
 39	KUNIT_EXPECT_FALSE(current_test, preemptible());
 40	/* This can be called on the fprobe_selftest_target and the fprobe_selftest_target2 */
 41	if (ip != target_ip)
 42		KUNIT_EXPECT_EQ(current_test, ip, target2_ip);
 43	entry_val = (rand1 / div_factor);
 44	if (fp->entry_data_size) {
 45		KUNIT_EXPECT_NOT_NULL(current_test, data);
 46		if (data)
 47			*(u32 *)data = entry_val;
 48	} else
 49		KUNIT_EXPECT_NULL(current_test, data);
 50
 51	return entry_return_value;
 52}
 53
 54static notrace void fp_exit_handler(struct fprobe *fp, unsigned long ip,
 55				    unsigned long ret_ip,
 56				    struct ftrace_regs *fregs, void *data)
 57{
 58	unsigned long ret = ftrace_regs_get_return_value(fregs);
 59
 60	KUNIT_EXPECT_FALSE(current_test, preemptible());
 61	if (ip != target_ip) {
 62		KUNIT_EXPECT_EQ(current_test, ip, target2_ip);
 63		KUNIT_EXPECT_EQ(current_test, ret, (rand1 / div_factor) + 1);
 64	} else
 65		KUNIT_EXPECT_EQ(current_test, ret, (rand1 / div_factor));
 66	KUNIT_EXPECT_EQ(current_test, entry_val, (rand1 / div_factor));
 67	exit_val = entry_val + div_factor;
 68	if (fp->entry_data_size) {
 69		KUNIT_EXPECT_NOT_NULL(current_test, data);
 70		if (data)
 71			KUNIT_EXPECT_EQ(current_test, *(u32 *)data, entry_val);
 72	} else
 73		KUNIT_EXPECT_NULL(current_test, data);
 74}
 75
 76/* Test entry only (no rethook) */
 77static void test_fprobe_entry(struct kunit *test)
 78{
 79	struct fprobe fp_entry = {
 80		.entry_handler = fp_entry_handler,
 81	};
 82
 83	current_test = test;
 84
 85	/* Before register, unregister should be failed. */
 86	KUNIT_EXPECT_NE(test, 0, unregister_fprobe(&fp_entry));
 87	KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp_entry, "fprobe_selftest_target*", NULL));
 88
 89	entry_val = 0;
 90	exit_val = 0;
 91	target(rand1);
 92	KUNIT_EXPECT_NE(test, 0, entry_val);
 93	KUNIT_EXPECT_EQ(test, 0, exit_val);
 94
 95	entry_val = 0;
 96	exit_val = 0;
 97	target2(rand1);
 98	KUNIT_EXPECT_NE(test, 0, entry_val);
 99	KUNIT_EXPECT_EQ(test, 0, exit_val);
100
101	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp_entry));
102}
103
104static void test_fprobe(struct kunit *test)
105{
106	struct fprobe fp = {
107		.entry_handler = fp_entry_handler,
108		.exit_handler = fp_exit_handler,
109	};
110
111	current_test = test;
112	KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp, "fprobe_selftest_target*", NULL));
113
114	entry_val = 0;
115	exit_val = 0;
116	target(rand1);
117	KUNIT_EXPECT_NE(test, 0, entry_val);
118	KUNIT_EXPECT_EQ(test, entry_val + div_factor, exit_val);
119
120	entry_val = 0;
121	exit_val = 0;
122	target2(rand1);
123	KUNIT_EXPECT_NE(test, 0, entry_val);
124	KUNIT_EXPECT_EQ(test, entry_val + div_factor, exit_val);
125
126	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
127}
128
129static void test_fprobe_syms(struct kunit *test)
130{
131	static const char *syms[] = {"fprobe_selftest_target", "fprobe_selftest_target2"};
132	struct fprobe fp = {
133		.entry_handler = fp_entry_handler,
134		.exit_handler = fp_exit_handler,
135	};
136
137	current_test = test;
138	KUNIT_EXPECT_EQ(test, 0, register_fprobe_syms(&fp, syms, 2));
139
140	entry_val = 0;
141	exit_val = 0;
142	target(rand1);
143	KUNIT_EXPECT_NE(test, 0, entry_val);
144	KUNIT_EXPECT_EQ(test, entry_val + div_factor, exit_val);
145
146	entry_val = 0;
147	exit_val = 0;
148	target2(rand1);
149	KUNIT_EXPECT_NE(test, 0, entry_val);
150	KUNIT_EXPECT_EQ(test, entry_val + div_factor, exit_val);
151
152	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
153}
154
155/* Test private entry_data */
156static void test_fprobe_data(struct kunit *test)
157{
158	struct fprobe fp = {
159		.entry_handler = fp_entry_handler,
160		.exit_handler = fp_exit_handler,
161		.entry_data_size = sizeof(u32),
162	};
163
164	current_test = test;
165	KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp, "fprobe_selftest_target", NULL));
166
167	target(rand1);
168
169	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
170}
171
172static void test_fprobe_skip(struct kunit *test)
173{
174	struct fprobe fp = {
175		.entry_handler = fp_entry_handler,
176		.exit_handler = fp_exit_handler,
177	};
178
179	current_test = test;
180	KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp, "fprobe_selftest_target", NULL));
181
182	entry_return_value = 1;
183	entry_val = 0;
184	exit_val = 0;
185	target(rand1);
186	KUNIT_EXPECT_NE(test, 0, entry_val);
187	KUNIT_EXPECT_EQ(test, 0, exit_val);
188	KUNIT_EXPECT_EQ(test, 0, fp.nmissed);
189	entry_return_value = 0;
190
191	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
192}
193
194/* Handler for fprobe entry only case */
195static notrace int entry_only_handler(struct fprobe *fp, unsigned long ip,
196				      unsigned long ret_ip,
197				      struct ftrace_regs *fregs, void *data)
198{
199	KUNIT_EXPECT_FALSE(current_test, preemptible());
200	KUNIT_EXPECT_EQ(current_test, ip, target_ip);
201
202	entry_only_count++;
203	entry_only_val = (rand1 / div_factor);
204
205	return 0;
206}
207
208static notrace int fprobe_entry_multi_handler(struct fprobe *fp, unsigned long ip,
209					      unsigned long ret_ip,
210					      struct ftrace_regs *fregs,
211					      void *data)
212{
213	KUNIT_EXPECT_FALSE(current_test, preemptible());
214	KUNIT_EXPECT_EQ(current_test, ip, target_ip);
215
216	entry_count++;
217	entry_val = (rand1 / div_factor);
218
219	return 0;
220}
221
222static notrace void fprobe_exit_multi_handler(struct fprobe *fp, unsigned long ip,
223					      unsigned long ret_ip,
224					      struct ftrace_regs *fregs,
225					      void *data)
226{
227	unsigned long ret = ftrace_regs_get_return_value(fregs);
228
229	KUNIT_EXPECT_FALSE(current_test, preemptible());
230	KUNIT_EXPECT_EQ(current_test, ip, target_ip);
231	KUNIT_EXPECT_EQ(current_test, ret, (rand1 / div_factor));
232
233	exit_count++;
234	exit_val = ret;
235}
236
237static void check_fprobe_multi(struct kunit *test)
238{
239	entry_only_count = entry_count = exit_count = 0;
240	entry_only_val = entry_val = exit_val = 0;
241
242	target(rand1);
243
244	/* Verify all handlers were called */
245	KUNIT_EXPECT_EQ(test, 1, entry_only_count);
246	KUNIT_EXPECT_EQ(test, 1, entry_count);
247	KUNIT_EXPECT_EQ(test, 1, exit_count);
248
249	/* Verify values are correct */
250	KUNIT_EXPECT_EQ(test, (rand1 / div_factor), entry_only_val);
251	KUNIT_EXPECT_EQ(test, (rand1 / div_factor), entry_val);
252	KUNIT_EXPECT_EQ(test, (rand1 / div_factor), exit_val);
253}
254
255/* Test multiple fprobes hooking the same target function */
256static void test_fprobe_multi(struct kunit *test)
257{
258	struct fprobe fp1 = {
259		.entry_handler = fprobe_entry_multi_handler,
260		.exit_handler = fprobe_exit_multi_handler,
261	};
262	struct fprobe fp2 = {
263		.entry_handler = entry_only_handler,
264	};
265
266	current_test = test;
267
268	/* Test Case 1: Register in order 1 -> 2 */
269	KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp1, "fprobe_selftest_target", NULL));
270	KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp2, "fprobe_selftest_target", NULL));
271
272	check_fprobe_multi(test);
273
274	/* Unregister all */
275	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp1));
276	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp2));
277
278	/* Test Case 2: Register in order 2 -> 1 */
279	KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp2, "fprobe_selftest_target", NULL));
280	KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp1, "fprobe_selftest_target", NULL));
281
282	check_fprobe_multi(test);
283
284	/* Unregister all */
285	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp1));
286	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp2));
287}
288
289static unsigned long get_ftrace_location(void *func)
290{
291	unsigned long size, addr = (unsigned long)func;
292
293	if (!kallsyms_lookup_size_offset(addr, &size, NULL) || !size)
294		return 0;
295
296	return ftrace_location_range(addr, addr + size - 1);
297}
298
299static int fprobe_test_init(struct kunit *test)
300{
301	rand1 = get_random_u32_above(div_factor);
302	target = fprobe_selftest_target;
303	target2 = fprobe_selftest_target2;
304	target_ip = get_ftrace_location(target);
305	target2_ip = get_ftrace_location(target2);
306
307	return 0;
308}
309
310static struct kunit_case fprobe_testcases[] = {
311	KUNIT_CASE(test_fprobe_entry),
312	KUNIT_CASE(test_fprobe),
313	KUNIT_CASE(test_fprobe_syms),
314	KUNIT_CASE(test_fprobe_data),
315	KUNIT_CASE(test_fprobe_skip),
316	KUNIT_CASE(test_fprobe_multi),
317	{}
318};
319
320static struct kunit_suite fprobe_test_suite = {
321	.name = "fprobe_test",
322	.init = fprobe_test_init,
323	.test_cases = fprobe_testcases,
324};
325
326kunit_test_suites(&fprobe_test_suite);
327