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 #include <linux/kernel.h> 9 #include <linux/kprobes.h> 10 #include <linux/random.h> 11 #include <kunit/test.h> 12 13 #define div_factor 3 14 15 static u32 rand1, preh_val, posth_val; 16 static u32 (*target)(u32 value); 17 static u32 (*target2)(u32 value); 18 static struct kunit *current_test; 19 20 static unsigned long (*internal_target)(void); 21 static unsigned long (*stacktrace_target)(void); 22 static unsigned long (*stacktrace_driver)(void); 23 static unsigned long target_return_address[2]; 24 25 static noinline u32 kprobe_target(u32 value) 26 { 27 return (value / div_factor); 28 } 29 30 static int kp_pre_handler(struct kprobe *p, struct pt_regs *regs) 31 { 32 KUNIT_EXPECT_FALSE(current_test, preemptible()); 33 preh_val = (rand1 / div_factor); 34 return 0; 35 } 36 37 static void kp_post_handler(struct kprobe *p, struct pt_regs *regs, 38 unsigned long flags) 39 { 40 KUNIT_EXPECT_FALSE(current_test, preemptible()); 41 KUNIT_EXPECT_EQ(current_test, preh_val, (rand1 / div_factor)); 42 posth_val = preh_val + div_factor; 43 } 44 45 static struct kprobe kp = { 46 .symbol_name = "kprobe_target", 47 .pre_handler = kp_pre_handler, 48 .post_handler = kp_post_handler 49 }; 50 51 static void test_kprobe(struct kunit *test) 52 { 53 current_test = test; 54 KUNIT_EXPECT_EQ(test, 0, register_kprobe(&kp)); 55 target(rand1); 56 unregister_kprobe(&kp); 57 KUNIT_EXPECT_NE(test, 0, preh_val); 58 KUNIT_EXPECT_NE(test, 0, posth_val); 59 } 60 61 static noinline u32 kprobe_target2(u32 value) 62 { 63 return (value / div_factor) + 1; 64 } 65 66 static noinline unsigned long kprobe_stacktrace_internal_target(void) 67 { 68 if (!target_return_address[0]) 69 target_return_address[0] = (unsigned long)__builtin_return_address(0); 70 return target_return_address[0]; 71 } 72 73 static noinline unsigned long kprobe_stacktrace_target(void) 74 { 75 if (!target_return_address[1]) 76 target_return_address[1] = (unsigned long)__builtin_return_address(0); 77 78 if (internal_target) 79 internal_target(); 80 81 return target_return_address[1]; 82 } 83 84 static noinline unsigned long kprobe_stacktrace_driver(void) 85 { 86 if (stacktrace_target) 87 stacktrace_target(); 88 89 /* This is for preventing inlining the function */ 90 return (unsigned long)__builtin_return_address(0); 91 } 92 93 static int kp_pre_handler2(struct kprobe *p, struct pt_regs *regs) 94 { 95 preh_val = (rand1 / div_factor) + 1; 96 return 0; 97 } 98 99 static void kp_post_handler2(struct kprobe *p, struct pt_regs *regs, 100 unsigned long flags) 101 { 102 KUNIT_EXPECT_EQ(current_test, preh_val, (rand1 / div_factor) + 1); 103 posth_val = preh_val + div_factor; 104 } 105 106 static struct kprobe kp2 = { 107 .symbol_name = "kprobe_target2", 108 .pre_handler = kp_pre_handler2, 109 .post_handler = kp_post_handler2 110 }; 111 112 static void test_kprobes(struct kunit *test) 113 { 114 struct kprobe *kps[2] = {&kp, &kp2}; 115 116 current_test = test; 117 118 /* addr and flags should be cleard for reusing kprobe. */ 119 kp.addr = NULL; 120 kp.flags = 0; 121 122 KUNIT_EXPECT_EQ(test, 0, register_kprobes(kps, 2)); 123 preh_val = 0; 124 posth_val = 0; 125 target(rand1); 126 127 KUNIT_EXPECT_NE(test, 0, preh_val); 128 KUNIT_EXPECT_NE(test, 0, posth_val); 129 130 preh_val = 0; 131 posth_val = 0; 132 target2(rand1); 133 134 KUNIT_EXPECT_NE(test, 0, preh_val); 135 KUNIT_EXPECT_NE(test, 0, posth_val); 136 unregister_kprobes(kps, 2); 137 } 138 139 #ifdef CONFIG_KRETPROBES 140 static u32 krph_val; 141 142 static int entry_handler(struct kretprobe_instance *ri, struct pt_regs *regs) 143 { 144 KUNIT_EXPECT_FALSE(current_test, preemptible()); 145 krph_val = (rand1 / div_factor); 146 return 0; 147 } 148 149 static int return_handler(struct kretprobe_instance *ri, struct pt_regs *regs) 150 { 151 unsigned long ret = regs_return_value(regs); 152 153 KUNIT_EXPECT_FALSE(current_test, preemptible()); 154 KUNIT_EXPECT_EQ(current_test, ret, rand1 / div_factor); 155 KUNIT_EXPECT_NE(current_test, krph_val, 0); 156 krph_val = rand1; 157 return 0; 158 } 159 160 static struct kretprobe rp = { 161 .handler = return_handler, 162 .entry_handler = entry_handler, 163 .kp.symbol_name = "kprobe_target" 164 }; 165 166 static void test_kretprobe(struct kunit *test) 167 { 168 current_test = test; 169 KUNIT_EXPECT_EQ(test, 0, register_kretprobe(&rp)); 170 target(rand1); 171 unregister_kretprobe(&rp); 172 KUNIT_EXPECT_EQ(test, krph_val, rand1); 173 } 174 175 static int return_handler2(struct kretprobe_instance *ri, struct pt_regs *regs) 176 { 177 unsigned long ret = regs_return_value(regs); 178 179 KUNIT_EXPECT_EQ(current_test, ret, (rand1 / div_factor) + 1); 180 KUNIT_EXPECT_NE(current_test, krph_val, 0); 181 krph_val = rand1; 182 return 0; 183 } 184 185 static struct kretprobe rp2 = { 186 .handler = return_handler2, 187 .entry_handler = entry_handler, 188 .kp.symbol_name = "kprobe_target2" 189 }; 190 191 static void test_kretprobes(struct kunit *test) 192 { 193 struct kretprobe *rps[2] = {&rp, &rp2}; 194 195 current_test = test; 196 /* addr and flags should be cleard for reusing kprobe. */ 197 rp.kp.addr = NULL; 198 rp.kp.flags = 0; 199 KUNIT_EXPECT_EQ(test, 0, register_kretprobes(rps, 2)); 200 201 krph_val = 0; 202 target(rand1); 203 KUNIT_EXPECT_EQ(test, krph_val, rand1); 204 205 krph_val = 0; 206 target2(rand1); 207 KUNIT_EXPECT_EQ(test, krph_val, rand1); 208 unregister_kretprobes(rps, 2); 209 } 210 211 #ifdef CONFIG_ARCH_CORRECT_STACKTRACE_ON_KRETPROBE 212 #define STACK_BUF_SIZE 16 213 static unsigned long stack_buf[STACK_BUF_SIZE]; 214 215 static int stacktrace_return_handler(struct kretprobe_instance *ri, struct pt_regs *regs) 216 { 217 unsigned long retval = regs_return_value(regs); 218 int i, ret; 219 220 KUNIT_EXPECT_FALSE(current_test, preemptible()); 221 KUNIT_EXPECT_EQ(current_test, retval, target_return_address[1]); 222 223 /* 224 * Test stacktrace inside the kretprobe handler, this will involves 225 * kretprobe trampoline, but must include correct return address 226 * of the target function. 227 */ 228 ret = stack_trace_save(stack_buf, STACK_BUF_SIZE, 0); 229 KUNIT_EXPECT_NE(current_test, ret, 0); 230 231 for (i = 0; i < ret; i++) { 232 if (stack_buf[i] == target_return_address[1]) 233 break; 234 } 235 KUNIT_EXPECT_NE(current_test, i, ret); 236 237 #if !IS_MODULE(CONFIG_KPROBES_SANITY_TEST) 238 /* 239 * Test stacktrace from pt_regs at the return address. Thus the stack 240 * trace must start from the target return address. 241 */ 242 ret = stack_trace_save_regs(regs, stack_buf, STACK_BUF_SIZE, 0); 243 KUNIT_EXPECT_NE(current_test, ret, 0); 244 KUNIT_EXPECT_EQ(current_test, stack_buf[0], target_return_address[1]); 245 #endif 246 247 return 0; 248 } 249 250 static struct kretprobe rp3 = { 251 .handler = stacktrace_return_handler, 252 .kp.symbol_name = "kprobe_stacktrace_target" 253 }; 254 255 static void test_stacktrace_on_kretprobe(struct kunit *test) 256 { 257 unsigned long myretaddr = (unsigned long)__builtin_return_address(0); 258 259 current_test = test; 260 rp3.kp.addr = NULL; 261 rp3.kp.flags = 0; 262 263 /* 264 * Run the stacktrace_driver() to record correct return address in 265 * stacktrace_target() and ensure stacktrace_driver() call is not 266 * inlined by checking the return address of stacktrace_driver() 267 * and the return address of this function is different. 268 */ 269 KUNIT_ASSERT_NE(test, myretaddr, stacktrace_driver()); 270 271 KUNIT_ASSERT_EQ(test, 0, register_kretprobe(&rp3)); 272 KUNIT_ASSERT_NE(test, myretaddr, stacktrace_driver()); 273 unregister_kretprobe(&rp3); 274 } 275 276 static int stacktrace_internal_return_handler(struct kretprobe_instance *ri, struct pt_regs *regs) 277 { 278 unsigned long retval = regs_return_value(regs); 279 int i, ret; 280 281 KUNIT_EXPECT_FALSE(current_test, preemptible()); 282 KUNIT_EXPECT_EQ(current_test, retval, target_return_address[0]); 283 284 /* 285 * Test stacktrace inside the kretprobe handler for nested case. 286 * The unwinder will find the kretprobe_trampoline address on the 287 * return address, and kretprobe must solve that. 288 */ 289 ret = stack_trace_save(stack_buf, STACK_BUF_SIZE, 0); 290 KUNIT_EXPECT_NE(current_test, ret, 0); 291 292 for (i = 0; i < ret - 1; i++) { 293 if (stack_buf[i] == target_return_address[0]) { 294 KUNIT_EXPECT_EQ(current_test, stack_buf[i + 1], target_return_address[1]); 295 break; 296 } 297 } 298 KUNIT_EXPECT_NE(current_test, i, ret); 299 300 #if !IS_MODULE(CONFIG_KPROBES_SANITY_TEST) 301 /* Ditto for the regs version. */ 302 ret = stack_trace_save_regs(regs, stack_buf, STACK_BUF_SIZE, 0); 303 KUNIT_EXPECT_NE(current_test, ret, 0); 304 KUNIT_EXPECT_EQ(current_test, stack_buf[0], target_return_address[0]); 305 KUNIT_EXPECT_EQ(current_test, stack_buf[1], target_return_address[1]); 306 #endif 307 308 return 0; 309 } 310 311 static struct kretprobe rp4 = { 312 .handler = stacktrace_internal_return_handler, 313 .kp.symbol_name = "kprobe_stacktrace_internal_target" 314 }; 315 316 static void test_stacktrace_on_nested_kretprobe(struct kunit *test) 317 { 318 unsigned long myretaddr = (unsigned long)__builtin_return_address(0); 319 struct kretprobe *rps[2] = {&rp3, &rp4}; 320 321 current_test = test; 322 rp3.kp.addr = NULL; 323 rp3.kp.flags = 0; 324 325 //KUNIT_ASSERT_NE(test, myretaddr, stacktrace_driver()); 326 327 KUNIT_ASSERT_EQ(test, 0, register_kretprobes(rps, 2)); 328 KUNIT_ASSERT_NE(test, myretaddr, stacktrace_driver()); 329 unregister_kretprobes(rps, 2); 330 } 331 #endif /* CONFIG_ARCH_CORRECT_STACKTRACE_ON_KRETPROBE */ 332 333 #endif /* CONFIG_KRETPROBES */ 334 335 static int kprobes_test_init(struct kunit *test) 336 { 337 target = kprobe_target; 338 target2 = kprobe_target2; 339 stacktrace_target = kprobe_stacktrace_target; 340 internal_target = kprobe_stacktrace_internal_target; 341 stacktrace_driver = kprobe_stacktrace_driver; 342 343 do { 344 rand1 = get_random_u32(); 345 } while (rand1 <= div_factor); 346 return 0; 347 } 348 349 static struct kunit_case kprobes_testcases[] = { 350 KUNIT_CASE(test_kprobe), 351 KUNIT_CASE(test_kprobes), 352 #ifdef CONFIG_KRETPROBES 353 KUNIT_CASE(test_kretprobe), 354 KUNIT_CASE(test_kretprobes), 355 #ifdef CONFIG_ARCH_CORRECT_STACKTRACE_ON_KRETPROBE 356 KUNIT_CASE(test_stacktrace_on_kretprobe), 357 KUNIT_CASE(test_stacktrace_on_nested_kretprobe), 358 #endif 359 #endif 360 {} 361 }; 362 363 static struct kunit_suite kprobes_test_suite = { 364 .name = "kprobes_test", 365 .init = kprobes_test_init, 366 .test_cases = kprobes_testcases, 367 }; 368 369 kunit_test_suites(&kprobes_test_suite); 370 371 MODULE_LICENSE("GPL"); 372