Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us