the-tree/lib/test_kprobes.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * test_kprobes.c - simple sanity test for *probes
0004  *
0005  * Copyright IBM Corp. 2008
0006  */
0007
0008 #include <linux/kernel.h>
0009 #include <linux/kprobes.h>
0010 #include <linux/random.h>
0011 #include <kunit/test.h>
0012
0013 #define div_factor 3
0014
0015 static u32 rand1, preh_val, posth_val;
0016 static u32 (*target)(u32 value);
0017 static u32 (*target2)(u32 value);
0018 static struct kunit *current_test;
0019
0020 static unsigned long (*internal_target)(void);
0021 static unsigned long (*stacktrace_target)(void);
0022 static unsigned long (*stacktrace_driver)(void);
0023 static unsigned long target_return_address[2];
0024
0025 static noinline u32 kprobe_target(u32 value)
0026 {
0027     return (value / div_factor);
0028 }
0029
0030 static int kp_pre_handler(struct kprobe *p, struct pt_regs *regs)
0031 {
0032     KUNIT_EXPECT_FALSE(current_test, preemptible());
0033     preh_val = (rand1 / div_factor);
0034     return 0;
0035 }
0036
0037 static void kp_post_handler(struct kprobe *p, struct pt_regs *regs,
0038         unsigned long flags)
0039 {
0040     KUNIT_EXPECT_FALSE(current_test, preemptible());
0041     KUNIT_EXPECT_EQ(current_test, preh_val, (rand1 / div_factor));
0042     posth_val = preh_val + div_factor;
0043 }
0044
0045 static struct kprobe kp = {
0046     .symbol_name = "kprobe_target",
0047     .pre_handler = kp_pre_handler,
0048     .post_handler = kp_post_handler
0049 };
0050
0051 static void test_kprobe(struct kunit *test)
0052 {
0053     current_test = test;
0054     KUNIT_EXPECT_EQ(test, 0, register_kprobe(&kp));
0055     target(rand1);
0056     unregister_kprobe(&kp);
0057     KUNIT_EXPECT_NE(test, 0, preh_val);
0058     KUNIT_EXPECT_NE(test, 0, posth_val);
0059 }
0060
0061 static noinline u32 kprobe_target2(u32 value)
0062 {
0063     return (value / div_factor) + 1;
0064 }
0065
0066 static noinline unsigned long kprobe_stacktrace_internal_target(void)
0067 {
0068     if (!target_return_address[0])
0069         target_return_address[0] = (unsigned long)__builtin_return_address(0);
0070     return target_return_address[0];
0071 }
0072
0073 static noinline unsigned long kprobe_stacktrace_target(void)
0074 {
0075     if (!target_return_address[1])
0076         target_return_address[1] = (unsigned long)__builtin_return_address(0);
0077
0078     if (internal_target)
0079         internal_target();
0080
0081     return target_return_address[1];
0082 }
0083
0084 static noinline unsigned long kprobe_stacktrace_driver(void)
0085 {
0086     if (stacktrace_target)
0087         stacktrace_target();
0088
0089     /* This is for preventing inlining the function */
0090     return (unsigned long)__builtin_return_address(0);
0091 }
0092
0093 static int kp_pre_handler2(struct kprobe *p, struct pt_regs *regs)
0094 {
0095     preh_val = (rand1 / div_factor) + 1;
0096     return 0;
0097 }
0098
0099 static void kp_post_handler2(struct kprobe *p, struct pt_regs *regs,
0100         unsigned long flags)
0101 {
0102     KUNIT_EXPECT_EQ(current_test, preh_val, (rand1 / div_factor) + 1);
0103     posth_val = preh_val + div_factor;
0104 }
0105
0106 static struct kprobe kp2 = {
0107     .symbol_name = "kprobe_target2",
0108     .pre_handler = kp_pre_handler2,
0109     .post_handler = kp_post_handler2
0110 };
0111
0112 static void test_kprobes(struct kunit *test)
0113 {
0114     struct kprobe *kps[2] = {&kp, &kp2};
0115
0116     current_test = test;
0117
0118     /* addr and flags should be cleard for reusing kprobe. */
0119     kp.addr = NULL;
0120     kp.flags = 0;
0121
0122     KUNIT_EXPECT_EQ(test, 0, register_kprobes(kps, 2));
0123     preh_val = 0;
0124     posth_val = 0;
0125     target(rand1);
0126
0127     KUNIT_EXPECT_NE(test, 0, preh_val);
0128     KUNIT_EXPECT_NE(test, 0, posth_val);
0129
0130     preh_val = 0;
0131     posth_val = 0;
0132     target2(rand1);
0133
0134     KUNIT_EXPECT_NE(test, 0, preh_val);
0135     KUNIT_EXPECT_NE(test, 0, posth_val);
0136     unregister_kprobes(kps, 2);
0137 }
0138
0139 #ifdef CONFIG_KRETPROBES
0140 static u32 krph_val;
0141
0142 static int entry_handler(struct kretprobe_instance *ri, struct pt_regs *regs)
0143 {
0144     KUNIT_EXPECT_FALSE(current_test, preemptible());
0145     krph_val = (rand1 / div_factor);
0146     return 0;
0147 }
0148
0149 static int return_handler(struct kretprobe_instance *ri, struct pt_regs *regs)
0150 {
0151     unsigned long ret = regs_return_value(regs);
0152
0153     KUNIT_EXPECT_FALSE(current_test, preemptible());
0154     KUNIT_EXPECT_EQ(current_test, ret, rand1 / div_factor);
0155     KUNIT_EXPECT_NE(current_test, krph_val, 0);
0156     krph_val = rand1;
0157     return 0;
0158 }
0159
0160 static struct kretprobe rp = {
0161     .handler    = return_handler,
0162     .entry_handler  = entry_handler,
0163     .kp.symbol_name = "kprobe_target"
0164 };
0165
0166 static void test_kretprobe(struct kunit *test)
0167 {
0168     current_test = test;
0169     KUNIT_EXPECT_EQ(test, 0, register_kretprobe(&rp));
0170     target(rand1);
0171     unregister_kretprobe(&rp);
0172     KUNIT_EXPECT_EQ(test, krph_val, rand1);
0173 }
0174
0175 static int return_handler2(struct kretprobe_instance *ri, struct pt_regs *regs)
0176 {
0177     unsigned long ret = regs_return_value(regs);
0178
0179     KUNIT_EXPECT_EQ(current_test, ret, (rand1 / div_factor) + 1);
0180     KUNIT_EXPECT_NE(current_test, krph_val, 0);
0181     krph_val = rand1;
0182     return 0;
0183 }
0184
0185 static struct kretprobe rp2 = {
0186     .handler    = return_handler2,
0187     .entry_handler  = entry_handler,
0188     .kp.symbol_name = "kprobe_target2"
0189 };
0190
0191 static void test_kretprobes(struct kunit *test)
0192 {
0193     struct kretprobe *rps[2] = {&rp, &rp2};
0194
0195     current_test = test;
0196     /* addr and flags should be cleard for reusing kprobe. */
0197     rp.kp.addr = NULL;
0198     rp.kp.flags = 0;
0199     KUNIT_EXPECT_EQ(test, 0, register_kretprobes(rps, 2));
0200
0201     krph_val = 0;
0202     target(rand1);
0203     KUNIT_EXPECT_EQ(test, krph_val, rand1);
0204
0205     krph_val = 0;
0206     target2(rand1);
0207     KUNIT_EXPECT_EQ(test, krph_val, rand1);
0208     unregister_kretprobes(rps, 2);
0209 }
0210
0211 #ifdef CONFIG_ARCH_CORRECT_STACKTRACE_ON_KRETPROBE
0212 #define STACK_BUF_SIZE 16
0213 static unsigned long stack_buf[STACK_BUF_SIZE];
0214
0215 static int stacktrace_return_handler(struct kretprobe_instance *ri, struct pt_regs *regs)
0216 {
0217     unsigned long retval = regs_return_value(regs);
0218     int i, ret;
0219
0220     KUNIT_EXPECT_FALSE(current_test, preemptible());
0221     KUNIT_EXPECT_EQ(current_test, retval, target_return_address[1]);
0222
0223     /*
0224      * Test stacktrace inside the kretprobe handler, this will involves
0225      * kretprobe trampoline, but must include correct return address
0226      * of the target function.
0227      */
0228     ret = stack_trace_save(stack_buf, STACK_BUF_SIZE, 0);
0229     KUNIT_EXPECT_NE(current_test, ret, 0);
0230
0231     for (i = 0; i < ret; i++) {
0232         if (stack_buf[i] == target_return_address[1])
0233             break;
0234     }
0235     KUNIT_EXPECT_NE(current_test, i, ret);
0236
0237 #if !IS_MODULE(CONFIG_KPROBES_SANITY_TEST)
0238     /*
0239      * Test stacktrace from pt_regs at the return address. Thus the stack
0240      * trace must start from the target return address.
0241      */
0242     ret = stack_trace_save_regs(regs, stack_buf, STACK_BUF_SIZE, 0);
0243     KUNIT_EXPECT_NE(current_test, ret, 0);
0244     KUNIT_EXPECT_EQ(current_test, stack_buf[0], target_return_address[1]);
0245 #endif
0246
0247     return 0;
0248 }
0249
0250 static struct kretprobe rp3 = {
0251     .handler    = stacktrace_return_handler,
0252     .kp.symbol_name = "kprobe_stacktrace_target"
0253 };
0254
0255 static void test_stacktrace_on_kretprobe(struct kunit *test)
0256 {
0257     unsigned long myretaddr = (unsigned long)__builtin_return_address(0);
0258
0259     current_test = test;
0260     rp3.kp.addr = NULL;
0261     rp3.kp.flags = 0;
0262
0263     /*
0264      * Run the stacktrace_driver() to record correct return address in
0265      * stacktrace_target() and ensure stacktrace_driver() call is not
0266      * inlined by checking the return address of stacktrace_driver()
0267      * and the return address of this function is different.
0268      */
0269     KUNIT_ASSERT_NE(test, myretaddr, stacktrace_driver());
0270
0271     KUNIT_ASSERT_EQ(test, 0, register_kretprobe(&rp3));
0272     KUNIT_ASSERT_NE(test, myretaddr, stacktrace_driver());
0273     unregister_kretprobe(&rp3);
0274 }
0275
0276 static int stacktrace_internal_return_handler(struct kretprobe_instance *ri, struct pt_regs *regs)
0277 {
0278     unsigned long retval = regs_return_value(regs);
0279     int i, ret;
0280
0281     KUNIT_EXPECT_FALSE(current_test, preemptible());
0282     KUNIT_EXPECT_EQ(current_test, retval, target_return_address[0]);
0283
0284     /*
0285      * Test stacktrace inside the kretprobe handler for nested case.
0286      * The unwinder will find the kretprobe_trampoline address on the
0287      * return address, and kretprobe must solve that.
0288      */
0289     ret = stack_trace_save(stack_buf, STACK_BUF_SIZE, 0);
0290     KUNIT_EXPECT_NE(current_test, ret, 0);
0291
0292     for (i = 0; i < ret - 1; i++) {
0293         if (stack_buf[i] == target_return_address[0]) {
0294             KUNIT_EXPECT_EQ(current_test, stack_buf[i + 1], target_return_address[1]);
0295             break;
0296         }
0297     }
0298     KUNIT_EXPECT_NE(current_test, i, ret);
0299
0300 #if !IS_MODULE(CONFIG_KPROBES_SANITY_TEST)
0301     /* Ditto for the regs version. */
0302     ret = stack_trace_save_regs(regs, stack_buf, STACK_BUF_SIZE, 0);
0303     KUNIT_EXPECT_NE(current_test, ret, 0);
0304     KUNIT_EXPECT_EQ(current_test, stack_buf[0], target_return_address[0]);
0305     KUNIT_EXPECT_EQ(current_test, stack_buf[1], target_return_address[1]);
0306 #endif
0307
0308     return 0;
0309 }
0310
0311 static struct kretprobe rp4 = {
0312     .handler    = stacktrace_internal_return_handler,
0313     .kp.symbol_name = "kprobe_stacktrace_internal_target"
0314 };
0315
0316 static void test_stacktrace_on_nested_kretprobe(struct kunit *test)
0317 {
0318     unsigned long myretaddr = (unsigned long)__builtin_return_address(0);
0319     struct kretprobe *rps[2] = {&rp3, &rp4};
0320
0321     current_test = test;
0322     rp3.kp.addr = NULL;
0323     rp3.kp.flags = 0;
0324
0325     //KUNIT_ASSERT_NE(test, myretaddr, stacktrace_driver());
0326
0327     KUNIT_ASSERT_EQ(test, 0, register_kretprobes(rps, 2));
0328     KUNIT_ASSERT_NE(test, myretaddr, stacktrace_driver());
0329     unregister_kretprobes(rps, 2);
0330 }
0331 #endif /* CONFIG_ARCH_CORRECT_STACKTRACE_ON_KRETPROBE */
0332
0333 #endif /* CONFIG_KRETPROBES */
0334
0335 static int kprobes_test_init(struct kunit *test)
0336 {
0337     target = kprobe_target;
0338     target2 = kprobe_target2;
0339     stacktrace_target = kprobe_stacktrace_target;
0340     internal_target = kprobe_stacktrace_internal_target;
0341     stacktrace_driver = kprobe_stacktrace_driver;
0342
0343     do {
0344         rand1 = prandom_u32();
0345     } while (rand1 <= div_factor);
0346     return 0;
0347 }
0348
0349 static struct kunit_case kprobes_testcases[] = {
0350     KUNIT_CASE(test_kprobe),
0351     KUNIT_CASE(test_kprobes),
0352 #ifdef CONFIG_KRETPROBES
0353     KUNIT_CASE(test_kretprobe),
0354     KUNIT_CASE(test_kretprobes),
0355 #ifdef CONFIG_ARCH_CORRECT_STACKTRACE_ON_KRETPROBE
0356     KUNIT_CASE(test_stacktrace_on_kretprobe),
0357     KUNIT_CASE(test_stacktrace_on_nested_kretprobe),
0358 #endif
0359 #endif
0360     {}
0361 };
0362
0363 static struct kunit_suite kprobes_test_suite = {
0364     .name = "kprobes_test",
0365     .init = kprobes_test_init,
0366     .test_cases = kprobes_testcases,
0367 };
0368
0369 kunit_test_suites(&kprobes_test_suite);
0370
0371 MODULE_LICENSE("GPL");