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