Commit | Line | Data |
---|---|---|
8c1c9356 AM |
1 | /* |
2 | * test_kprobes.c - simple sanity test for *probes | |
3 | * | |
4 | * Copyright IBM Corp. 2008 | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License as published by | |
8 | * the Free Software Foundation; either version 2 of the License, or | |
9 | * (at your option) any later version. | |
10 | * | |
11 | * This program is distributed in the hope that it would be useful, but | |
12 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See | |
14 | * the GNU General Public License for more details. | |
15 | */ | |
16 | ||
4878b14b FF |
17 | #define pr_fmt(fmt) "Kprobe smoke test: " fmt |
18 | ||
8c1c9356 AM |
19 | #include <linux/kernel.h> |
20 | #include <linux/kprobes.h> | |
21 | #include <linux/random.h> | |
22 | ||
23 | #define div_factor 3 | |
24 | ||
25 | static u32 rand1, preh_val, posth_val, jph_val; | |
26 | static int errors, handler_errors, num_tests; | |
8e114405 | 27 | static u32 (*target)(u32 value); |
12da3b88 | 28 | static u32 (*target2)(u32 value); |
8c1c9356 AM |
29 | |
30 | static noinline u32 kprobe_target(u32 value) | |
31 | { | |
8c1c9356 AM |
32 | return (value / div_factor); |
33 | } | |
34 | ||
35 | static int kp_pre_handler(struct kprobe *p, struct pt_regs *regs) | |
36 | { | |
3539d091 MH |
37 | if (preemptible()) { |
38 | handler_errors++; | |
39 | pr_err("pre-handler is preemptible\n"); | |
40 | } | |
8c1c9356 AM |
41 | preh_val = (rand1 / div_factor); |
42 | return 0; | |
43 | } | |
44 | ||
45 | static void kp_post_handler(struct kprobe *p, struct pt_regs *regs, | |
46 | unsigned long flags) | |
47 | { | |
3539d091 MH |
48 | if (preemptible()) { |
49 | handler_errors++; | |
50 | pr_err("post-handler is preemptible\n"); | |
51 | } | |
8c1c9356 AM |
52 | if (preh_val != (rand1 / div_factor)) { |
53 | handler_errors++; | |
4878b14b | 54 | pr_err("incorrect value in post_handler\n"); |
8c1c9356 AM |
55 | } |
56 | posth_val = preh_val + div_factor; | |
57 | } | |
58 | ||
59 | static struct kprobe kp = { | |
60 | .symbol_name = "kprobe_target", | |
61 | .pre_handler = kp_pre_handler, | |
62 | .post_handler = kp_post_handler | |
63 | }; | |
64 | ||
65 | static int test_kprobe(void) | |
66 | { | |
67 | int ret; | |
68 | ||
69 | ret = register_kprobe(&kp); | |
70 | if (ret < 0) { | |
4878b14b | 71 | pr_err("register_kprobe returned %d\n", ret); |
8c1c9356 AM |
72 | return ret; |
73 | } | |
74 | ||
8e114405 | 75 | ret = target(rand1); |
8c1c9356 AM |
76 | unregister_kprobe(&kp); |
77 | ||
78 | if (preh_val == 0) { | |
4878b14b | 79 | pr_err("kprobe pre_handler not called\n"); |
8c1c9356 AM |
80 | handler_errors++; |
81 | } | |
82 | ||
83 | if (posth_val == 0) { | |
4878b14b | 84 | pr_err("kprobe post_handler not called\n"); |
8c1c9356 AM |
85 | handler_errors++; |
86 | } | |
87 | ||
88 | return 0; | |
89 | } | |
90 | ||
12da3b88 MH |
91 | static noinline u32 kprobe_target2(u32 value) |
92 | { | |
93 | return (value / div_factor) + 1; | |
94 | } | |
95 | ||
96 | static int kp_pre_handler2(struct kprobe *p, struct pt_regs *regs) | |
97 | { | |
98 | preh_val = (rand1 / div_factor) + 1; | |
99 | return 0; | |
100 | } | |
101 | ||
102 | static void kp_post_handler2(struct kprobe *p, struct pt_regs *regs, | |
103 | unsigned long flags) | |
104 | { | |
105 | if (preh_val != (rand1 / div_factor) + 1) { | |
106 | handler_errors++; | |
4878b14b | 107 | pr_err("incorrect value in post_handler2\n"); |
12da3b88 MH |
108 | } |
109 | posth_val = preh_val + div_factor; | |
110 | } | |
111 | ||
112 | static struct kprobe kp2 = { | |
113 | .symbol_name = "kprobe_target2", | |
114 | .pre_handler = kp_pre_handler2, | |
115 | .post_handler = kp_post_handler2 | |
116 | }; | |
117 | ||
118 | static int test_kprobes(void) | |
119 | { | |
120 | int ret; | |
121 | struct kprobe *kps[2] = {&kp, &kp2}; | |
122 | ||
fd02e6f7 MH |
123 | /* addr and flags should be cleard for reusing kprobe. */ |
124 | kp.addr = NULL; | |
125 | kp.flags = 0; | |
12da3b88 MH |
126 | ret = register_kprobes(kps, 2); |
127 | if (ret < 0) { | |
4878b14b | 128 | pr_err("register_kprobes returned %d\n", ret); |
12da3b88 MH |
129 | return ret; |
130 | } | |
131 | ||
132 | preh_val = 0; | |
133 | posth_val = 0; | |
134 | ret = target(rand1); | |
135 | ||
136 | if (preh_val == 0) { | |
4878b14b | 137 | pr_err("kprobe pre_handler not called\n"); |
12da3b88 MH |
138 | handler_errors++; |
139 | } | |
140 | ||
141 | if (posth_val == 0) { | |
4878b14b | 142 | pr_err("kprobe post_handler not called\n"); |
12da3b88 MH |
143 | handler_errors++; |
144 | } | |
145 | ||
146 | preh_val = 0; | |
147 | posth_val = 0; | |
148 | ret = target2(rand1); | |
149 | ||
150 | if (preh_val == 0) { | |
4878b14b | 151 | pr_err("kprobe pre_handler2 not called\n"); |
12da3b88 MH |
152 | handler_errors++; |
153 | } | |
154 | ||
155 | if (posth_val == 0) { | |
4878b14b | 156 | pr_err("kprobe post_handler2 not called\n"); |
12da3b88 MH |
157 | handler_errors++; |
158 | } | |
159 | ||
160 | unregister_kprobes(kps, 2); | |
161 | return 0; | |
162 | ||
163 | } | |
164 | ||
8c1c9356 AM |
165 | static u32 j_kprobe_target(u32 value) |
166 | { | |
3539d091 MH |
167 | if (preemptible()) { |
168 | handler_errors++; | |
169 | pr_err("jprobe-handler is preemptible\n"); | |
170 | } | |
8c1c9356 AM |
171 | if (value != rand1) { |
172 | handler_errors++; | |
4878b14b | 173 | pr_err("incorrect value in jprobe handler\n"); |
8c1c9356 AM |
174 | } |
175 | ||
176 | jph_val = rand1; | |
177 | jprobe_return(); | |
178 | return 0; | |
179 | } | |
180 | ||
181 | static struct jprobe jp = { | |
182 | .entry = j_kprobe_target, | |
183 | .kp.symbol_name = "kprobe_target" | |
184 | }; | |
185 | ||
186 | static int test_jprobe(void) | |
187 | { | |
188 | int ret; | |
189 | ||
190 | ret = register_jprobe(&jp); | |
191 | if (ret < 0) { | |
4878b14b | 192 | pr_err("register_jprobe returned %d\n", ret); |
8c1c9356 AM |
193 | return ret; |
194 | } | |
195 | ||
8e114405 | 196 | ret = target(rand1); |
8c1c9356 AM |
197 | unregister_jprobe(&jp); |
198 | if (jph_val == 0) { | |
4878b14b | 199 | pr_err("jprobe handler not called\n"); |
8c1c9356 AM |
200 | handler_errors++; |
201 | } | |
202 | ||
203 | return 0; | |
204 | } | |
205 | ||
12da3b88 MH |
206 | static struct jprobe jp2 = { |
207 | .entry = j_kprobe_target, | |
208 | .kp.symbol_name = "kprobe_target2" | |
209 | }; | |
210 | ||
211 | static int test_jprobes(void) | |
212 | { | |
213 | int ret; | |
214 | struct jprobe *jps[2] = {&jp, &jp2}; | |
215 | ||
fd02e6f7 MH |
216 | /* addr and flags should be cleard for reusing kprobe. */ |
217 | jp.kp.addr = NULL; | |
218 | jp.kp.flags = 0; | |
12da3b88 MH |
219 | ret = register_jprobes(jps, 2); |
220 | if (ret < 0) { | |
4878b14b | 221 | pr_err("register_jprobes returned %d\n", ret); |
12da3b88 MH |
222 | return ret; |
223 | } | |
224 | ||
225 | jph_val = 0; | |
226 | ret = target(rand1); | |
227 | if (jph_val == 0) { | |
4878b14b | 228 | pr_err("jprobe handler not called\n"); |
12da3b88 MH |
229 | handler_errors++; |
230 | } | |
231 | ||
232 | jph_val = 0; | |
233 | ret = target2(rand1); | |
234 | if (jph_val == 0) { | |
4878b14b | 235 | pr_err("jprobe handler2 not called\n"); |
12da3b88 MH |
236 | handler_errors++; |
237 | } | |
238 | unregister_jprobes(jps, 2); | |
239 | ||
240 | return 0; | |
241 | } | |
8c1c9356 AM |
242 | #ifdef CONFIG_KRETPROBES |
243 | static u32 krph_val; | |
244 | ||
f47cd9b5 AS |
245 | static int entry_handler(struct kretprobe_instance *ri, struct pt_regs *regs) |
246 | { | |
3539d091 MH |
247 | if (preemptible()) { |
248 | handler_errors++; | |
249 | pr_err("kretprobe entry handler is preemptible\n"); | |
250 | } | |
f47cd9b5 AS |
251 | krph_val = (rand1 / div_factor); |
252 | return 0; | |
253 | } | |
254 | ||
8c1c9356 AM |
255 | static int return_handler(struct kretprobe_instance *ri, struct pt_regs *regs) |
256 | { | |
257 | unsigned long ret = regs_return_value(regs); | |
258 | ||
3539d091 MH |
259 | if (preemptible()) { |
260 | handler_errors++; | |
261 | pr_err("kretprobe return handler is preemptible\n"); | |
262 | } | |
8c1c9356 AM |
263 | if (ret != (rand1 / div_factor)) { |
264 | handler_errors++; | |
4878b14b | 265 | pr_err("incorrect value in kretprobe handler\n"); |
8c1c9356 | 266 | } |
f47cd9b5 AS |
267 | if (krph_val == 0) { |
268 | handler_errors++; | |
4878b14b | 269 | pr_err("call to kretprobe entry handler failed\n"); |
f47cd9b5 | 270 | } |
8c1c9356 | 271 | |
f47cd9b5 | 272 | krph_val = rand1; |
8c1c9356 AM |
273 | return 0; |
274 | } | |
275 | ||
276 | static struct kretprobe rp = { | |
277 | .handler = return_handler, | |
f47cd9b5 | 278 | .entry_handler = entry_handler, |
8c1c9356 AM |
279 | .kp.symbol_name = "kprobe_target" |
280 | }; | |
281 | ||
282 | static int test_kretprobe(void) | |
283 | { | |
284 | int ret; | |
285 | ||
286 | ret = register_kretprobe(&rp); | |
287 | if (ret < 0) { | |
4878b14b | 288 | pr_err("register_kretprobe returned %d\n", ret); |
8c1c9356 AM |
289 | return ret; |
290 | } | |
291 | ||
8e114405 | 292 | ret = target(rand1); |
8c1c9356 | 293 | unregister_kretprobe(&rp); |
f47cd9b5 | 294 | if (krph_val != rand1) { |
4878b14b | 295 | pr_err("kretprobe handler not called\n"); |
8c1c9356 AM |
296 | handler_errors++; |
297 | } | |
298 | ||
299 | return 0; | |
300 | } | |
12da3b88 MH |
301 | |
302 | static int return_handler2(struct kretprobe_instance *ri, struct pt_regs *regs) | |
303 | { | |
304 | unsigned long ret = regs_return_value(regs); | |
305 | ||
306 | if (ret != (rand1 / div_factor) + 1) { | |
307 | handler_errors++; | |
4878b14b | 308 | pr_err("incorrect value in kretprobe handler2\n"); |
12da3b88 MH |
309 | } |
310 | if (krph_val == 0) { | |
311 | handler_errors++; | |
4878b14b | 312 | pr_err("call to kretprobe entry handler failed\n"); |
12da3b88 MH |
313 | } |
314 | ||
315 | krph_val = rand1; | |
316 | return 0; | |
317 | } | |
318 | ||
319 | static struct kretprobe rp2 = { | |
320 | .handler = return_handler2, | |
321 | .entry_handler = entry_handler, | |
322 | .kp.symbol_name = "kprobe_target2" | |
323 | }; | |
324 | ||
325 | static int test_kretprobes(void) | |
326 | { | |
327 | int ret; | |
328 | struct kretprobe *rps[2] = {&rp, &rp2}; | |
329 | ||
fd02e6f7 MH |
330 | /* addr and flags should be cleard for reusing kprobe. */ |
331 | rp.kp.addr = NULL; | |
332 | rp.kp.flags = 0; | |
12da3b88 MH |
333 | ret = register_kretprobes(rps, 2); |
334 | if (ret < 0) { | |
4878b14b | 335 | pr_err("register_kretprobe returned %d\n", ret); |
12da3b88 MH |
336 | return ret; |
337 | } | |
338 | ||
339 | krph_val = 0; | |
340 | ret = target(rand1); | |
341 | if (krph_val != rand1) { | |
4878b14b | 342 | pr_err("kretprobe handler not called\n"); |
12da3b88 MH |
343 | handler_errors++; |
344 | } | |
345 | ||
346 | krph_val = 0; | |
347 | ret = target2(rand1); | |
348 | if (krph_val != rand1) { | |
4878b14b | 349 | pr_err("kretprobe handler2 not called\n"); |
12da3b88 MH |
350 | handler_errors++; |
351 | } | |
352 | unregister_kretprobes(rps, 2); | |
353 | return 0; | |
354 | } | |
8c1c9356 AM |
355 | #endif /* CONFIG_KRETPROBES */ |
356 | ||
357 | int init_test_probes(void) | |
358 | { | |
359 | int ret; | |
360 | ||
8e114405 | 361 | target = kprobe_target; |
12da3b88 | 362 | target2 = kprobe_target2; |
8e114405 | 363 | |
8c1c9356 | 364 | do { |
6d65df33 | 365 | rand1 = prandom_u32(); |
8c1c9356 AM |
366 | } while (rand1 <= div_factor); |
367 | ||
4878b14b | 368 | pr_info("started\n"); |
8c1c9356 AM |
369 | num_tests++; |
370 | ret = test_kprobe(); | |
371 | if (ret < 0) | |
372 | errors++; | |
373 | ||
12da3b88 MH |
374 | num_tests++; |
375 | ret = test_kprobes(); | |
376 | if (ret < 0) | |
377 | errors++; | |
378 | ||
8c1c9356 AM |
379 | num_tests++; |
380 | ret = test_jprobe(); | |
381 | if (ret < 0) | |
382 | errors++; | |
383 | ||
12da3b88 MH |
384 | num_tests++; |
385 | ret = test_jprobes(); | |
386 | if (ret < 0) | |
387 | errors++; | |
388 | ||
8c1c9356 AM |
389 | #ifdef CONFIG_KRETPROBES |
390 | num_tests++; | |
391 | ret = test_kretprobe(); | |
392 | if (ret < 0) | |
393 | errors++; | |
12da3b88 MH |
394 | |
395 | num_tests++; | |
396 | ret = test_kretprobes(); | |
397 | if (ret < 0) | |
398 | errors++; | |
8c1c9356 AM |
399 | #endif /* CONFIG_KRETPROBES */ |
400 | ||
401 | if (errors) | |
4878b14b | 402 | pr_err("BUG: %d out of %d tests failed\n", errors, num_tests); |
8c1c9356 | 403 | else if (handler_errors) |
4878b14b | 404 | pr_err("BUG: %d error(s) running handlers\n", handler_errors); |
8c1c9356 | 405 | else |
4878b14b | 406 | pr_info("passed successfully\n"); |
8c1c9356 AM |
407 | |
408 | return 0; | |
409 | } |