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, symbolsize: &size, NULL) || !size) |
240 | return 0; |
241 | |
242 | return ftrace_location_range(start: addr, end: 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(func: target); |
252 | target2_ip = get_ftrace_location(func: target2); |
253 | target_nest_ip = get_ftrace_location(func: 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 | |