lib/test_fprobe.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * test_fprobe.c - simple sanity test for fprobe
   4  */
   5
   6 #include <linux/kernel.h>
   7 #include <linux/fprobe.h>
   8 #include <linux/random.h>
   9 #include <kunit/test.h>
  10
  11 #define div_factor 3
  12
  13 static struct kunit *current_test;
  14
  15 static u32 rand1, entry_val, exit_val;
  16
  17 /* Use indirect calls to avoid inlining the target functions */
  18 static u32 (*target)(u32 value);
  19 static u32 (*target2)(u32 value);
  20 static u32 (*target_nest)(u32 value, u32 (*nest)(u32));
  21 static unsigned long target_ip;
  22 static unsigned long target2_ip;
  23 static unsigned long target_nest_ip;
  24
  25 static noinline u32 fprobe_selftest_target(u32 value)
  26 {
  27         return (value / div_factor);
  28 }
  29
  30 static noinline u32 fprobe_selftest_target2(u32 value)
  31 {
  32         return (value / div_factor) + 1;
  33 }
  34
  35 static noinline u32 fprobe_selftest_nest_target(u32 value, u32 (*nest)(u32))
  36 {
  37         return nest(value + 2);
  38 }
  39
  40 static notrace int fp_entry_handler(struct fprobe *fp, unsigned long ip,
  41                                      struct pt_regs *regs, void *data)
  42 {
  43         KUNIT_EXPECT_FALSE(current_test, preemptible());
  44         /* This can be called on the fprobe_selftest_target and the fprobe_selftest_target2 */
  45         if (ip != target_ip)
  46                 KUNIT_EXPECT_EQ(current_test, ip, target2_ip);
  47         entry_val = (rand1 / div_factor);
  48         if (fp->entry_data_size) {
  49                 KUNIT_EXPECT_NOT_NULL(current_test, data);
  50                 if (data)
  51                         *(u32 *)data = entry_val;
  52         } else
  53                 KUNIT_EXPECT_NULL(current_test, data);
  54
  55         return 0;
  56 }
  57
  58 static notrace void fp_exit_handler(struct fprobe *fp, unsigned long ip,
  59                                     struct pt_regs *regs, void *data)
  60 {
  61         unsigned long ret = regs_return_value(regs);
  62
  63         KUNIT_EXPECT_FALSE(current_test, preemptible());
  64         if (ip != target_ip) {
  65                 KUNIT_EXPECT_EQ(current_test, ip, target2_ip);
  66                 KUNIT_EXPECT_EQ(current_test, ret, (rand1 / div_factor) + 1);
  67         } else
  68                 KUNIT_EXPECT_EQ(current_test, ret, (rand1 / div_factor));
  69         KUNIT_EXPECT_EQ(current_test, entry_val, (rand1 / div_factor));
  70         exit_val = entry_val + div_factor;
  71         if (fp->entry_data_size) {
  72                 KUNIT_EXPECT_NOT_NULL(current_test, data);
  73                 if (data)
  74                         KUNIT_EXPECT_EQ(current_test, *(u32 *)data, entry_val);
  75         } else
  76                 KUNIT_EXPECT_NULL(current_test, data);
  77 }
  78
  79 static notrace int nest_entry_handler(struct fprobe *fp, unsigned long ip,
  80                                      struct pt_regs *regs, void *data)
  81 {
  82         KUNIT_EXPECT_FALSE(current_test, preemptible());
  83         return 0;
  84 }
  85
  86 static notrace void nest_exit_handler(struct fprobe *fp, unsigned long ip,
  87                                     struct pt_regs *regs, void *data)
  88 {
  89         KUNIT_EXPECT_FALSE(current_test, preemptible());
  90         KUNIT_EXPECT_EQ(current_test, ip, target_nest_ip);
  91 }
  92
  93 /* Test entry only (no rethook) */
  94 static void test_fprobe_entry(struct kunit *test)
  95 {
  96         struct fprobe fp_entry = {
  97                 .entry_handler = fp_entry_handler,
  98         };
  99
 100         current_test = test;
 101
 102         /* Before register, unregister should be failed. */
 103         KUNIT_EXPECT_NE(test, 0, unregister_fprobe(&fp_entry));
 104         KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp_entry, "fprobe_selftest_target*", NULL));
 105
 106         entry_val = 0;
 107         exit_val = 0;
 108         target(rand1);
 109         KUNIT_EXPECT_NE(test, 0, entry_val);
 110         KUNIT_EXPECT_EQ(test, 0, exit_val);
 111
 112         entry_val = 0;
 113         exit_val = 0;
 114         target2(rand1);
 115         KUNIT_EXPECT_NE(test, 0, entry_val);
 116         KUNIT_EXPECT_EQ(test, 0, exit_val);
 117
 118         KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp_entry));
 119 }
 120
 121 static void test_fprobe(struct kunit *test)
 122 {
 123         struct fprobe fp = {
 124                 .entry_handler = fp_entry_handler,
 125                 .exit_handler = fp_exit_handler,
 126         };
 127
 128         current_test = test;
 129         KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp, "fprobe_selftest_target*", NULL));
 130
 131         entry_val = 0;
 132         exit_val = 0;
 133         target(rand1);
 134         KUNIT_EXPECT_NE(test, 0, entry_val);
 135         KUNIT_EXPECT_EQ(test, entry_val + div_factor, exit_val);
 136
 137         entry_val = 0;
 138         exit_val = 0;
 139         target2(rand1);
 140         KUNIT_EXPECT_NE(test, 0, entry_val);
 141         KUNIT_EXPECT_EQ(test, entry_val + div_factor, exit_val);
 142
 143         KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
 144 }
 145
 146 static void test_fprobe_syms(struct kunit *test)
 147 {
 148         static const char *syms[] = {"fprobe_selftest_target", "fprobe_selftest_target2"};
 149         struct fprobe fp = {
 150                 .entry_handler = fp_entry_handler,
 151                 .exit_handler = fp_exit_handler,
 152         };
 153
 154         current_test = test;
 155         KUNIT_EXPECT_EQ(test, 0, register_fprobe_syms(&fp, syms, 2));
 156
 157         entry_val = 0;
 158         exit_val = 0;
 159         target(rand1);
 160         KUNIT_EXPECT_NE(test, 0, entry_val);
 161         KUNIT_EXPECT_EQ(test, entry_val + div_factor, exit_val);
 162
 163         entry_val = 0;
 164         exit_val = 0;
 165         target2(rand1);
 166         KUNIT_EXPECT_NE(test, 0, entry_val);
 167         KUNIT_EXPECT_EQ(test, entry_val + div_factor, exit_val);
 168
 169         KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
 170 }
 171
 172 /* Test private entry_data */
 173 static void test_fprobe_data(struct kunit *test)
 174 {
 175         struct fprobe fp = {
 176                 .entry_handler = fp_entry_handler,
 177                 .exit_handler = fp_exit_handler,
 178                 .entry_data_size = sizeof(u32),
 179         };
 180
 181         current_test = test;
 182         KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp, "fprobe_selftest_target", NULL));
 183
 184         target(rand1);
 185
 186         KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
 187 }
 188
 189 /* Test nr_maxactive */
 190 static void test_fprobe_nest(struct kunit *test)
 191 {
 192         static const char *syms[] = {"fprobe_selftest_target", "fprobe_selftest_nest_target"};
 193         struct fprobe fp = {
 194                 .entry_handler = nest_entry_handler,
 195                 .exit_handler = nest_exit_handler,
 196                 .nr_maxactive = 1,
 197         };
 198
 199         current_test = test;
 200         KUNIT_EXPECT_EQ(test, 0, register_fprobe_syms(&fp, syms, 2));
 201
 202         target_nest(rand1, target);
 203         KUNIT_EXPECT_EQ(test, 1, fp.nmissed);
 204
 205         KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
 206 }
 207
 208 static unsigned long get_ftrace_location(void *func)
 209 {
 210         unsigned long size, addr = (unsigned long)func;
 211
 212         if (!kallsyms_lookup_size_offset(addr, &size, NULL) || !size)
 213                 return 0;
 214
 215         return ftrace_location_range(addr, addr + size - 1);
 216 }
 217
 218 static int fprobe_test_init(struct kunit *test)
 219 {
 220         rand1 = get_random_u32_above(div_factor);
 221         target = fprobe_selftest_target;
 222         target2 = fprobe_selftest_target2;
 223         target_nest = fprobe_selftest_nest_target;
 224         target_ip = get_ftrace_location(target);
 225         target2_ip = get_ftrace_location(target2);
 226         target_nest_ip = get_ftrace_location(target_nest);
 227
 228         return 0;
 229 }
 230
 231 static struct kunit_case fprobe_testcases[] = {
 232         KUNIT_CASE(test_fprobe_entry),
 233         KUNIT_CASE(test_fprobe),
 234         KUNIT_CASE(test_fprobe_syms),
 235         KUNIT_CASE(test_fprobe_data),
 236         KUNIT_CASE(test_fprobe_nest),
 237         {}
 238 };
 239
 240 static struct kunit_suite fprobe_test_suite = {
 241         .name = "fprobe_test",
 242         .init = fprobe_test_init,
 243         .test_cases = fprobe_testcases,
 244 };
 245
 246 kunit_test_suites(&fprobe_test_suite);
 247
 248 MODULE_LICENSE("GPL");