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