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