x86: kprobes: add kprobes smoke tests that run on boot
[linux-2.6.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
26 static noinline u32 kprobe_target(u32 value)
27 {
28         /*
29          * gcc ignores noinline on some architectures unless we stuff
30          * sufficient lard into the function. The get_kprobe() here is
31          * just for that.
32          *
33          * NOTE: We aren't concerned about the correctness of get_kprobe()
34          * here; hence, this call is neither under !preempt nor with the
35          * kprobe_mutex held. This is fine(tm)
36          */
37         if (get_kprobe((void *)0xdeadbeef))
38                 printk(KERN_INFO "Kprobe smoke test: probe on 0xdeadbeef!\n");
39
40         return (value / div_factor);
41 }
42
43 static int kp_pre_handler(struct kprobe *p, struct pt_regs *regs)
44 {
45         preh_val = (rand1 / div_factor);
46         return 0;
47 }
48
49 static void kp_post_handler(struct kprobe *p, struct pt_regs *regs,
50                 unsigned long flags)
51 {
52         if (preh_val != (rand1 / div_factor)) {
53                 handler_errors++;
54                 printk(KERN_ERR "Kprobe smoke test failed: "
55                                 "incorrect value in post_handler\n");
56         }
57         posth_val = preh_val + div_factor;
58 }
59
60 static struct kprobe kp = {
61         .symbol_name = "kprobe_target",
62         .pre_handler = kp_pre_handler,
63         .post_handler = kp_post_handler
64 };
65
66 static int test_kprobe(void)
67 {
68         int ret;
69
70         ret = register_kprobe(&kp);
71         if (ret < 0) {
72                 printk(KERN_ERR "Kprobe smoke test failed: "
73                                 "register_kprobe returned %d\n", ret);
74                 return ret;
75         }
76
77         ret = kprobe_target(rand1);
78         unregister_kprobe(&kp);
79
80         if (preh_val == 0) {
81                 printk(KERN_ERR "Kprobe smoke test failed: "
82                                 "kprobe pre_handler not called\n");
83                 handler_errors++;
84         }
85
86         if (posth_val == 0) {
87                 printk(KERN_ERR "Kprobe smoke test failed: "
88                                 "kprobe post_handler not called\n");
89                 handler_errors++;
90         }
91
92         return 0;
93 }
94
95 static u32 j_kprobe_target(u32 value)
96 {
97         if (value != rand1) {
98                 handler_errors++;
99                 printk(KERN_ERR "Kprobe smoke test failed: "
100                                 "incorrect value in jprobe handler\n");
101         }
102
103         jph_val = rand1;
104         jprobe_return();
105         return 0;
106 }
107
108 static struct jprobe jp = {
109         .entry          = j_kprobe_target,
110         .kp.symbol_name = "kprobe_target"
111 };
112
113 static int test_jprobe(void)
114 {
115         int ret;
116
117         ret = register_jprobe(&jp);
118         if (ret < 0) {
119                 printk(KERN_ERR "Kprobe smoke test failed: "
120                                 "register_jprobe returned %d\n", ret);
121                 return ret;
122         }
123
124         ret = kprobe_target(rand1);
125         unregister_jprobe(&jp);
126         if (jph_val == 0) {
127                 printk(KERN_ERR "Kprobe smoke test failed: "
128                                 "jprobe handler not called\n");
129                 handler_errors++;
130         }
131
132         return 0;
133 }
134
135 #ifdef CONFIG_KRETPROBES
136 static u32 krph_val;
137
138 static int return_handler(struct kretprobe_instance *ri, struct pt_regs *regs)
139 {
140         unsigned long ret = regs_return_value(regs);
141
142         if (ret != (rand1 / div_factor)) {
143                 handler_errors++;
144                 printk(KERN_ERR "Kprobe smoke test failed: "
145                                 "incorrect value in kretprobe handler\n");
146         }
147
148         krph_val = (rand1 / div_factor);
149         return 0;
150 }
151
152 static struct kretprobe rp = {
153         .handler        = return_handler,
154         .kp.symbol_name = "kprobe_target"
155 };
156
157 static int test_kretprobe(void)
158 {
159         int ret;
160
161         ret = register_kretprobe(&rp);
162         if (ret < 0) {
163                 printk(KERN_ERR "Kprobe smoke test failed: "
164                                 "register_kretprobe returned %d\n", ret);
165                 return ret;
166         }
167
168         ret = kprobe_target(rand1);
169         unregister_kretprobe(&rp);
170         if (krph_val == 0) {
171                 printk(KERN_ERR "Kprobe smoke test failed: "
172                                 "kretprobe handler not called\n");
173                 handler_errors++;
174         }
175
176         return 0;
177 }
178 #endif /* CONFIG_KRETPROBES */
179
180 int init_test_probes(void)
181 {
182         int ret;
183
184         do {
185                 rand1 = random32();
186         } while (rand1 <= div_factor);
187
188         printk(KERN_INFO "Kprobe smoke test started\n");
189         num_tests++;
190         ret = test_kprobe();
191         if (ret < 0)
192                 errors++;
193
194         num_tests++;
195         ret = test_jprobe();
196         if (ret < 0)
197                 errors++;
198
199 #ifdef CONFIG_KRETPROBES
200         num_tests++;
201         ret = test_kretprobe();
202         if (ret < 0)
203                 errors++;
204 #endif /* CONFIG_KRETPROBES */
205
206         if (errors)
207                 printk(KERN_ERR "BUG: Kprobe smoke test: %d out of "
208                                 "%d tests failed\n", errors, num_tests);
209         else if (handler_errors)
210                 printk(KERN_ERR "BUG: Kprobe smoke test: %d error(s) "
211                                 "running handlers\n", handler_errors);
212         else
213                 printk(KERN_INFO "Kprobe smoke test passed successfully\n");
214
215         return 0;
216 }