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;
  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         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
  45 static 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
  59 static struct kprobe kp = {
  60         .symbol_name = "kprobe_target",
  61         .pre_handler = kp_pre_handler,
  62         .post_handler = kp_post_handler
  63 };
  64
  65 static 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
  91 static noinline u32 kprobe_target2(u32 value)
  92 {
  93         return (value / div_factor) + 1;
  94 }
  95
  96 static int kp_pre_handler2(struct kprobe *p, struct pt_regs *regs)
  97 {
  98         preh_val = (rand1 / div_factor) + 1;
  99         return 0;
 100 }
 101
 102 static 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
 112 static struct kprobe kp2 = {
 113         .symbol_name = "kprobe_target2",
 114         .pre_handler = kp_pre_handler2,
 115         .post_handler = kp_post_handler2
 116 };
 117
 118 static 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
 166 static u32 jph_val;
 167
 168 static 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
 184 static struct jprobe jp = {
 185         .entry          = j_kprobe_target,
 186         .kp.symbol_name = "kprobe_target"
 187 };
 188
 189 static 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
 209 static struct jprobe jp2 = {
 210         .entry          = j_kprobe_target,
 211         .kp.symbol_name = "kprobe_target2"
 212 };
 213
 214 static 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
 250 static u32 krph_val;
 251
 252 static 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
 262 static 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
 283 static struct kretprobe rp = {
 284         .handler        = return_handler,
 285         .entry_handler  = entry_handler,
 286         .kp.symbol_name = "kprobe_target"
 287 };
 288
 289 static 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
 309 static 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
 326 static struct kretprobe rp2 = {
 327         .handler        = return_handler2,
 328         .entry_handler  = entry_handler,
 329         .kp.symbol_name = "kprobe_target2"
 330 };
 331
 332 static 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
 364 int 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 }