kernel/test_kprobes.c

   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
  16 static u32 rand1, preh_val, posth_val;
  17 static int errors, handler_errors, num_tests;
  18 static u32 (*target)(u32 value);
  19 static u32 (*target2)(u32 value);
  20
  21 static noinline u32 kprobe_target(u32 value)
  22 {
  23         return (value / div_factor);
  24 }
  25
  26 static 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
  36 static 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
  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                 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
  82 static noinline u32 kprobe_target2(u32 value)
  83 {
  84         return (value / div_factor) + 1;
  85 }
  86
  87 static int kp_pre_handler2(struct kprobe *p, struct pt_regs *regs)
  88 {
  89         preh_val = (rand1 / div_factor) + 1;
  90         return 0;
  91 }
  92
  93 static 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
 103 static struct kprobe kp2 = {
 104         .symbol_name = "kprobe_target2",
 105         .pre_handler = kp_pre_handler2,
 106         .post_handler = kp_post_handler2
 107 };
 108
 109 static 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
 157 static u32 krph_val;
 158
 159 static 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
 169 static 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
 190 static struct kretprobe rp = {
 191         .handler        = return_handler,
 192         .entry_handler  = entry_handler,
 193         .kp.symbol_name = "kprobe_target"
 194 };
 195
 196 static 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
 216 static 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
 233 static struct kretprobe rp2 = {
 234         .handler        = return_handler2,
 235         .entry_handler  = entry_handler,
 236         .kp.symbol_name = "kprobe_target2"
 237 };
 238
 239 static 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
 271 int 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 }