xref: /openbmc/linux/lib/test_fprobe.c (revision 2a598d0b)
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);
20 static u32 (*target_nest)(u32 value, u32 (*nest)(u32));
21 static unsigned long target_ip;
22 static unsigned long target2_ip;
23 static unsigned long target_nest_ip;
24 static int entry_return_value;
25 
26 static noinline u32 fprobe_selftest_target(u32 value)
27 {
28 	return (value / div_factor);
29 }
30 
31 static noinline u32 fprobe_selftest_target2(u32 value)
32 {
33 	return (value / div_factor) + 1;
34 }
35 
36 static noinline u32 fprobe_selftest_nest_target(u32 value, u32 (*nest)(u32))
37 {
38 	return nest(value + 2);
39 }
40 
41 static notrace int fp_entry_handler(struct fprobe *fp, unsigned long ip,
42 				    unsigned long ret_ip,
43 				    struct pt_regs *regs, void *data)
44 {
45 	KUNIT_EXPECT_FALSE(current_test, preemptible());
46 	/* This can be called on the fprobe_selftest_target and the fprobe_selftest_target2 */
47 	if (ip != target_ip)
48 		KUNIT_EXPECT_EQ(current_test, ip, target2_ip);
49 	entry_val = (rand1 / div_factor);
50 	if (fp->entry_data_size) {
51 		KUNIT_EXPECT_NOT_NULL(current_test, data);
52 		if (data)
53 			*(u32 *)data = entry_val;
54 	} else
55 		KUNIT_EXPECT_NULL(current_test, data);
56 
57 	return entry_return_value;
58 }
59 
60 static notrace void fp_exit_handler(struct fprobe *fp, unsigned long ip,
61 				    unsigned long ret_ip,
62 				    struct pt_regs *regs, void *data)
63 {
64 	unsigned long ret = regs_return_value(regs);
65 
66 	KUNIT_EXPECT_FALSE(current_test, preemptible());
67 	if (ip != target_ip) {
68 		KUNIT_EXPECT_EQ(current_test, ip, target2_ip);
69 		KUNIT_EXPECT_EQ(current_test, ret, (rand1 / div_factor) + 1);
70 	} else
71 		KUNIT_EXPECT_EQ(current_test, ret, (rand1 / div_factor));
72 	KUNIT_EXPECT_EQ(current_test, entry_val, (rand1 / div_factor));
73 	exit_val = entry_val + div_factor;
74 	if (fp->entry_data_size) {
75 		KUNIT_EXPECT_NOT_NULL(current_test, data);
76 		if (data)
77 			KUNIT_EXPECT_EQ(current_test, *(u32 *)data, entry_val);
78 	} else
79 		KUNIT_EXPECT_NULL(current_test, data);
80 }
81 
82 static notrace int nest_entry_handler(struct fprobe *fp, unsigned long ip,
83 				      unsigned long ret_ip,
84 				      struct pt_regs *regs, void *data)
85 {
86 	KUNIT_EXPECT_FALSE(current_test, preemptible());
87 	return 0;
88 }
89 
90 static notrace void nest_exit_handler(struct fprobe *fp, unsigned long ip,
91 				      unsigned long ret_ip,
92 				      struct pt_regs *regs, void *data)
93 {
94 	KUNIT_EXPECT_FALSE(current_test, preemptible());
95 	KUNIT_EXPECT_EQ(current_test, ip, target_nest_ip);
96 }
97 
98 /* Test entry only (no rethook) */
99 static void test_fprobe_entry(struct kunit *test)
100 {
101 	struct fprobe fp_entry = {
102 		.entry_handler = fp_entry_handler,
103 	};
104 
105 	current_test = test;
106 
107 	/* Before register, unregister should be failed. */
108 	KUNIT_EXPECT_NE(test, 0, unregister_fprobe(&fp_entry));
109 	KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp_entry, "fprobe_selftest_target*", NULL));
110 
111 	entry_val = 0;
112 	exit_val = 0;
113 	target(rand1);
114 	KUNIT_EXPECT_NE(test, 0, entry_val);
115 	KUNIT_EXPECT_EQ(test, 0, exit_val);
116 
117 	entry_val = 0;
118 	exit_val = 0;
119 	target2(rand1);
120 	KUNIT_EXPECT_NE(test, 0, entry_val);
121 	KUNIT_EXPECT_EQ(test, 0, exit_val);
122 
123 	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp_entry));
124 }
125 
126 static void test_fprobe(struct kunit *test)
127 {
128 	struct fprobe fp = {
129 		.entry_handler = fp_entry_handler,
130 		.exit_handler = fp_exit_handler,
131 	};
132 
133 	current_test = test;
134 	KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp, "fprobe_selftest_target*", NULL));
135 
136 	entry_val = 0;
137 	exit_val = 0;
138 	target(rand1);
139 	KUNIT_EXPECT_NE(test, 0, entry_val);
140 	KUNIT_EXPECT_EQ(test, entry_val + div_factor, exit_val);
141 
142 	entry_val = 0;
143 	exit_val = 0;
144 	target2(rand1);
145 	KUNIT_EXPECT_NE(test, 0, entry_val);
146 	KUNIT_EXPECT_EQ(test, entry_val + div_factor, exit_val);
147 
148 	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
149 }
150 
151 static void test_fprobe_syms(struct kunit *test)
152 {
153 	static const char *syms[] = {"fprobe_selftest_target", "fprobe_selftest_target2"};
154 	struct fprobe fp = {
155 		.entry_handler = fp_entry_handler,
156 		.exit_handler = fp_exit_handler,
157 	};
158 
159 	current_test = test;
160 	KUNIT_EXPECT_EQ(test, 0, register_fprobe_syms(&fp, syms, 2));
161 
162 	entry_val = 0;
163 	exit_val = 0;
164 	target(rand1);
165 	KUNIT_EXPECT_NE(test, 0, entry_val);
166 	KUNIT_EXPECT_EQ(test, entry_val + div_factor, exit_val);
167 
168 	entry_val = 0;
169 	exit_val = 0;
170 	target2(rand1);
171 	KUNIT_EXPECT_NE(test, 0, entry_val);
172 	KUNIT_EXPECT_EQ(test, entry_val + div_factor, exit_val);
173 
174 	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
175 }
176 
177 /* Test private entry_data */
178 static void test_fprobe_data(struct kunit *test)
179 {
180 	struct fprobe fp = {
181 		.entry_handler = fp_entry_handler,
182 		.exit_handler = fp_exit_handler,
183 		.entry_data_size = sizeof(u32),
184 	};
185 
186 	current_test = test;
187 	KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp, "fprobe_selftest_target", NULL));
188 
189 	target(rand1);
190 
191 	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
192 }
193 
194 /* Test nr_maxactive */
195 static void test_fprobe_nest(struct kunit *test)
196 {
197 	static const char *syms[] = {"fprobe_selftest_target", "fprobe_selftest_nest_target"};
198 	struct fprobe fp = {
199 		.entry_handler = nest_entry_handler,
200 		.exit_handler = nest_exit_handler,
201 		.nr_maxactive = 1,
202 	};
203 
204 	current_test = test;
205 	KUNIT_EXPECT_EQ(test, 0, register_fprobe_syms(&fp, syms, 2));
206 
207 	target_nest(rand1, target);
208 	KUNIT_EXPECT_EQ(test, 1, fp.nmissed);
209 
210 	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
211 }
212 
213 static void test_fprobe_skip(struct kunit *test)
214 {
215 	struct fprobe fp = {
216 		.entry_handler = fp_entry_handler,
217 		.exit_handler = fp_exit_handler,
218 	};
219 
220 	current_test = test;
221 	KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp, "fprobe_selftest_target", NULL));
222 
223 	entry_return_value = 1;
224 	entry_val = 0;
225 	exit_val = 0;
226 	target(rand1);
227 	KUNIT_EXPECT_NE(test, 0, entry_val);
228 	KUNIT_EXPECT_EQ(test, 0, exit_val);
229 	KUNIT_EXPECT_EQ(test, 0, fp.nmissed);
230 	entry_return_value = 0;
231 
232 	KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
233 }
234 
235 static unsigned long get_ftrace_location(void *func)
236 {
237 	unsigned long size, addr = (unsigned long)func;
238 
239 	if (!kallsyms_lookup_size_offset(addr, &size, NULL) || !size)
240 		return 0;
241 
242 	return ftrace_location_range(addr, addr + size - 1);
243 }
244 
245 static int fprobe_test_init(struct kunit *test)
246 {
247 	rand1 = get_random_u32_above(div_factor);
248 	target = fprobe_selftest_target;
249 	target2 = fprobe_selftest_target2;
250 	target_nest = fprobe_selftest_nest_target;
251 	target_ip = get_ftrace_location(target);
252 	target2_ip = get_ftrace_location(target2);
253 	target_nest_ip = get_ftrace_location(target_nest);
254 
255 	return 0;
256 }
257 
258 static struct kunit_case fprobe_testcases[] = {
259 	KUNIT_CASE(test_fprobe_entry),
260 	KUNIT_CASE(test_fprobe),
261 	KUNIT_CASE(test_fprobe_syms),
262 	KUNIT_CASE(test_fprobe_data),
263 	KUNIT_CASE(test_fprobe_nest),
264 	KUNIT_CASE(test_fprobe_skip),
265 	{}
266 };
267 
268 static struct kunit_suite fprobe_test_suite = {
269 	.name = "fprobe_test",
270 	.init = fprobe_test_init,
271 	.test_cases = fprobe_testcases,
272 };
273 
274 kunit_test_suites(&fprobe_test_suite);
275 
276