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 | ||
2c7d662e | 25 | static u32 rand1, preh_val, posth_val; |
8c1c9356 | 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 | ||
2c7d662e MH |
165 | #if 0 |
166 | static u32 jph_val; | |
167 | ||
8c1c9356 AM |
168 | static u32 j_kprobe_target(u32 value) |
169 | { | |
3539d091 MH |
170 | if (preemptible()) { |
171 | handler_errors++; | |
172 | pr_err("jprobe-handler is preemptible\n"); | |
173 | } | |
8c1c9356 AM |
174 | if (value != rand1) { |
175 | handler_errors++; | |
4878b14b | 176 | pr_err("incorrect value in jprobe handler\n"); |
8c1c9356 AM |
177 | } |
178 | ||
179 | jph_val = rand1; | |
180 | jprobe_return(); | |
181 | return 0; | |
182 | } | |
183 | ||
184 | static struct jprobe jp = { | |
185 | .entry = j_kprobe_target, | |
186 | .kp.symbol_name = "kprobe_target" | |
187 | }; | |
188 | ||
189 | static int test_jprobe(void) | |
190 | { | |
191 | int ret; | |
192 | ||
193 | ret = register_jprobe(&jp); | |
194 | if (ret < 0) { | |
4878b14b | 195 | pr_err("register_jprobe returned %d\n", ret); |
8c1c9356 AM |
196 | return ret; |
197 | } | |
198 | ||
8e114405 | 199 | ret = target(rand1); |
8c1c9356 AM |
200 | unregister_jprobe(&jp); |
201 | if (jph_val == 0) { | |
4878b14b | 202 | pr_err("jprobe handler not called\n"); |
8c1c9356 AM |
203 | handler_errors++; |
204 | } | |
205 | ||
206 | return 0; | |
207 | } | |
208 | ||
12da3b88 MH |
209 | static struct jprobe jp2 = { |
210 | .entry = j_kprobe_target, | |
211 | .kp.symbol_name = "kprobe_target2" | |
212 | }; | |
213 | ||
214 | static int test_jprobes(void) | |
215 | { | |
216 | int ret; | |
217 | struct jprobe *jps[2] = {&jp, &jp2}; | |
218 | ||
fd02e6f7 MH |
219 | /* addr and flags should be cleard for reusing kprobe. */ |
220 | jp.kp.addr = NULL; | |
221 | jp.kp.flags = 0; | |
12da3b88 MH |
222 | ret = register_jprobes(jps, 2); |
223 | if (ret < 0) { | |
4878b14b | 224 | pr_err("register_jprobes returned %d\n", ret); |
12da3b88 MH |
225 | return ret; |
226 | } | |
227 | ||
228 | jph_val = 0; | |
229 | ret = target(rand1); | |
230 | if (jph_val == 0) { | |
4878b14b | 231 | pr_err("jprobe handler not called\n"); |
12da3b88 MH |
232 | handler_errors++; |
233 | } | |
234 | ||
235 | jph_val = 0; | |
236 | ret = target2(rand1); | |
237 | if (jph_val == 0) { | |
4878b14b | 238 | pr_err("jprobe handler2 not called\n"); |
12da3b88 MH |
239 | handler_errors++; |
240 | } | |
241 | unregister_jprobes(jps, 2); | |
242 | ||
243 | return 0; | |
244 | } | |
2c7d662e MH |
245 | #else |
246 | #define test_jprobe() (0) | |
247 | #define test_jprobes() (0) | |
248 | #endif | |
8c1c9356 AM |
249 | #ifdef CONFIG_KRETPROBES |
250 | static u32 krph_val; | |
251 | ||
f47cd9b5 AS |
252 | static int entry_handler(struct kretprobe_instance *ri, struct pt_regs *regs) |
253 | { | |
3539d091 MH |
254 | if (preemptible()) { |
255 | handler_errors++; | |
256 | pr_err("kretprobe entry handler is preemptible\n"); | |
257 | } | |
f47cd9b5 AS |
258 | krph_val = (rand1 / div_factor); |
259 | return 0; | |
260 | } | |
261 | ||
8c1c9356 AM |
262 | static int return_handler(struct kretprobe_instance *ri, struct pt_regs *regs) |
263 | { | |
264 | unsigned long ret = regs_return_value(regs); | |
265 | ||
3539d091 MH |
266 | if (preemptible()) { |
267 | handler_errors++; | |
268 | pr_err("kretprobe return handler is preemptible\n"); | |
269 | } | |
8c1c9356 AM |
270 | if (ret != (rand1 / div_factor)) { |
271 | handler_errors++; | |
4878b14b | 272 | pr_err("incorrect value in kretprobe handler\n"); |
8c1c9356 | 273 | } |
f47cd9b5 AS |
274 | if (krph_val == 0) { |
275 | handler_errors++; | |
4878b14b | 276 | pr_err("call to kretprobe entry handler failed\n"); |
f47cd9b5 | 277 | } |
8c1c9356 | 278 | |
f47cd9b5 | 279 | krph_val = rand1; |
8c1c9356 AM |
280 | return 0; |
281 | } | |
282 | ||
283 | static struct kretprobe rp = { | |
284 | .handler = return_handler, | |
f47cd9b5 | 285 | .entry_handler = entry_handler, |
8c1c9356 AM |
286 | .kp.symbol_name = "kprobe_target" |
287 | }; | |
288 | ||
289 | static int test_kretprobe(void) | |
290 | { | |
291 | int ret; | |
292 | ||
293 | ret = register_kretprobe(&rp); | |
294 | if (ret < 0) { | |
4878b14b | 295 | pr_err("register_kretprobe returned %d\n", ret); |
8c1c9356 AM |
296 | return ret; |
297 | } | |
298 | ||
8e114405 | 299 | ret = target(rand1); |
8c1c9356 | 300 | unregister_kretprobe(&rp); |
f47cd9b5 | 301 | if (krph_val != rand1) { |
4878b14b | 302 | pr_err("kretprobe handler not called\n"); |
8c1c9356 AM |
303 | handler_errors++; |
304 | } | |
305 | ||
306 | return 0; | |
307 | } | |
12da3b88 MH |
308 | |
309 | static int return_handler2(struct kretprobe_instance *ri, struct pt_regs *regs) | |
310 | { | |
311 | unsigned long ret = regs_return_value(regs); | |
312 | ||
313 | if (ret != (rand1 / div_factor) + 1) { | |
314 | handler_errors++; | |
4878b14b | 315 | pr_err("incorrect value in kretprobe handler2\n"); |
12da3b88 MH |
316 | } |
317 | if (krph_val == 0) { | |
318 | handler_errors++; | |
4878b14b | 319 | pr_err("call to kretprobe entry handler failed\n"); |
12da3b88 MH |
320 | } |
321 | ||
322 | krph_val = rand1; | |
323 | return 0; | |
324 | } | |
325 | ||
326 | static struct kretprobe rp2 = { | |
327 | .handler = return_handler2, | |
328 | .entry_handler = entry_handler, | |
329 | .kp.symbol_name = "kprobe_target2" | |
330 | }; | |
331 | ||
332 | static int test_kretprobes(void) | |
333 | { | |
334 | int ret; | |
335 | struct kretprobe *rps[2] = {&rp, &rp2}; | |
336 | ||
fd02e6f7 MH |
337 | /* addr and flags should be cleard for reusing kprobe. */ |
338 | rp.kp.addr = NULL; | |
339 | rp.kp.flags = 0; | |
12da3b88 MH |
340 | ret = register_kretprobes(rps, 2); |
341 | if (ret < 0) { | |
4878b14b | 342 | pr_err("register_kretprobe returned %d\n", ret); |
12da3b88 MH |
343 | return ret; |
344 | } | |
345 | ||
346 | krph_val = 0; | |
347 | ret = target(rand1); | |
348 | if (krph_val != rand1) { | |
4878b14b | 349 | pr_err("kretprobe handler not called\n"); |
12da3b88 MH |
350 | handler_errors++; |
351 | } | |
352 | ||
353 | krph_val = 0; | |
354 | ret = target2(rand1); | |
355 | if (krph_val != rand1) { | |
4878b14b | 356 | pr_err("kretprobe handler2 not called\n"); |
12da3b88 MH |
357 | handler_errors++; |
358 | } | |
359 | unregister_kretprobes(rps, 2); | |
360 | return 0; | |
361 | } | |
8c1c9356 AM |
362 | #endif /* CONFIG_KRETPROBES */ |
363 | ||
364 | int init_test_probes(void) | |
365 | { | |
366 | int ret; | |
367 | ||
8e114405 | 368 | target = kprobe_target; |
12da3b88 | 369 | target2 = kprobe_target2; |
8e114405 | 370 | |
8c1c9356 | 371 | do { |
6d65df33 | 372 | rand1 = prandom_u32(); |
8c1c9356 AM |
373 | } while (rand1 <= div_factor); |
374 | ||
4878b14b | 375 | pr_info("started\n"); |
8c1c9356 AM |
376 | num_tests++; |
377 | ret = test_kprobe(); | |
378 | if (ret < 0) | |
379 | errors++; | |
380 | ||
12da3b88 MH |
381 | num_tests++; |
382 | ret = test_kprobes(); | |
383 | if (ret < 0) | |
384 | errors++; | |
385 | ||
8c1c9356 AM |
386 | num_tests++; |
387 | ret = test_jprobe(); | |
388 | if (ret < 0) | |
389 | errors++; | |
390 | ||
12da3b88 MH |
391 | num_tests++; |
392 | ret = test_jprobes(); | |
393 | if (ret < 0) | |
394 | errors++; | |
395 | ||
8c1c9356 AM |
396 | #ifdef CONFIG_KRETPROBES |
397 | num_tests++; | |
398 | ret = test_kretprobe(); | |
399 | if (ret < 0) | |
400 | errors++; | |
12da3b88 MH |
401 | |
402 | num_tests++; | |
403 | ret = test_kretprobes(); | |
404 | if (ret < 0) | |
405 | errors++; | |
8c1c9356 AM |
406 | #endif /* CONFIG_KRETPROBES */ |
407 | ||
408 | if (errors) | |
4878b14b | 409 | pr_err("BUG: %d out of %d tests failed\n", errors, num_tests); |
8c1c9356 | 410 | else if (handler_errors) |
4878b14b | 411 | pr_err("BUG: %d error(s) running handlers\n", handler_errors); |
8c1c9356 | 412 | else |
4878b14b | 413 | pr_info("passed successfully\n"); |
8c1c9356 AM |
414 | |
415 | return 0; | |
416 | } |