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