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