1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Test module for unwind_for_each_frame 4 */ 5 6 #include <kunit/test.h> 7 #include <asm/unwind.h> 8 #include <linux/completion.h> 9 #include <linux/kallsyms.h> 10 #include <linux/kthread.h> 11 #include <linux/ftrace.h> 12 #include <linux/module.h> 13 #include <linux/timer.h> 14 #include <linux/slab.h> 15 #include <linux/string.h> 16 #include <linux/kprobes.h> 17 #include <linux/wait.h> 18 #include <asm/irq.h> 19 20 static struct kunit *current_test; 21 22 #define BT_BUF_SIZE (PAGE_SIZE * 4) 23 24 static bool force_bt; 25 module_param_named(backtrace, force_bt, bool, 0444); 26 MODULE_PARM_DESC(backtrace, "print backtraces for all tests"); 27 28 /* 29 * To avoid printk line limit split backtrace by lines 30 */ 31 static void print_backtrace(char *bt) 32 { 33 char *p; 34 35 while (true) { 36 p = strsep(&bt, "\n"); 37 if (!p) 38 break; 39 kunit_err(current_test, "%s\n", p); 40 } 41 } 42 43 /* 44 * Calls unwind_for_each_frame(task, regs, sp) and verifies that the result 45 * contains unwindme_func2 followed by unwindme_func1. 46 */ 47 static noinline int test_unwind(struct task_struct *task, struct pt_regs *regs, 48 unsigned long sp) 49 { 50 int frame_count, prev_is_func2, seen_func2_func1, seen_arch_rethook_trampoline; 51 const int max_frames = 128; 52 struct unwind_state state; 53 size_t bt_pos = 0; 54 int ret = 0; 55 char *bt; 56 57 bt = kmalloc(BT_BUF_SIZE, GFP_ATOMIC); 58 if (!bt) { 59 kunit_err(current_test, "failed to allocate backtrace buffer\n"); 60 return -ENOMEM; 61 } 62 /* Unwind. */ 63 frame_count = 0; 64 prev_is_func2 = 0; 65 seen_func2_func1 = 0; 66 seen_arch_rethook_trampoline = 0; 67 unwind_for_each_frame(&state, task, regs, sp) { 68 unsigned long addr = unwind_get_return_address(&state); 69 char sym[KSYM_SYMBOL_LEN]; 70 71 if (frame_count++ == max_frames) 72 break; 73 if (state.reliable && !addr) { 74 kunit_err(current_test, "unwind state reliable but addr is 0\n"); 75 ret = -EINVAL; 76 break; 77 } 78 sprint_symbol(sym, addr); 79 if (bt_pos < BT_BUF_SIZE) { 80 bt_pos += snprintf(bt + bt_pos, BT_BUF_SIZE - bt_pos, 81 state.reliable ? " [%-7s%px] %pSR\n" : 82 "([%-7s%px] %pSR)\n", 83 stack_type_name(state.stack_info.type), 84 (void *)state.sp, (void *)state.ip); 85 if (bt_pos >= BT_BUF_SIZE) 86 kunit_err(current_test, "backtrace buffer is too small\n"); 87 } 88 frame_count += 1; 89 if (prev_is_func2 && str_has_prefix(sym, "unwindme_func1")) 90 seen_func2_func1 = 1; 91 prev_is_func2 = str_has_prefix(sym, "unwindme_func2"); 92 if (str_has_prefix(sym, "arch_rethook_trampoline+0x0/")) 93 seen_arch_rethook_trampoline = 1; 94 } 95 96 /* Check the results. */ 97 if (unwind_error(&state)) { 98 kunit_err(current_test, "unwind error\n"); 99 ret = -EINVAL; 100 } 101 if (!seen_func2_func1) { 102 kunit_err(current_test, "unwindme_func2 and unwindme_func1 not found\n"); 103 ret = -EINVAL; 104 } 105 if (frame_count == max_frames) { 106 kunit_err(current_test, "Maximum number of frames exceeded\n"); 107 ret = -EINVAL; 108 } 109 if (seen_arch_rethook_trampoline) { 110 kunit_err(current_test, "arch_rethook_trampoline+0x0 in unwinding results\n"); 111 ret = -EINVAL; 112 } 113 if (ret || force_bt) 114 print_backtrace(bt); 115 kfree(bt); 116 return ret; 117 } 118 119 /* State of the task being unwound. */ 120 struct unwindme { 121 int flags; 122 int ret; 123 struct task_struct *task; 124 struct completion task_ready; 125 wait_queue_head_t task_wq; 126 unsigned long sp; 127 }; 128 129 static struct unwindme *unwindme; 130 131 /* Values of unwindme.flags. */ 132 #define UWM_DEFAULT 0x0 133 #define UWM_THREAD 0x1 /* Unwind a separate task. */ 134 #define UWM_REGS 0x2 /* Pass regs to test_unwind(). */ 135 #define UWM_SP 0x4 /* Pass sp to test_unwind(). */ 136 #define UWM_CALLER 0x8 /* Unwind starting from caller. */ 137 #define UWM_SWITCH_STACK 0x10 /* Use call_on_stack. */ 138 #define UWM_IRQ 0x20 /* Unwind from irq context. */ 139 #define UWM_PGM 0x40 /* Unwind from program check handler */ 140 #define UWM_KPROBE_ON_FTRACE 0x80 /* Unwind from kprobe handler called via ftrace. */ 141 #define UWM_FTRACE 0x100 /* Unwind from ftrace handler. */ 142 #define UWM_KRETPROBE 0x200 /* Unwind through kretprobed function. */ 143 #define UWM_KRETPROBE_HANDLER 0x400 /* Unwind from kretprobe handler. */ 144 145 static __always_inline struct pt_regs fake_pt_regs(void) 146 { 147 struct pt_regs regs; 148 149 memset(®s, 0, sizeof(regs)); 150 regs.gprs[15] = current_stack_pointer; 151 152 asm volatile( 153 "basr %[psw_addr],0\n" 154 : [psw_addr] "=d" (regs.psw.addr)); 155 return regs; 156 } 157 158 static int kretprobe_ret_handler(struct kretprobe_instance *ri, struct pt_regs *regs) 159 { 160 struct unwindme *u = unwindme; 161 162 if (!(u->flags & UWM_KRETPROBE_HANDLER)) 163 return 0; 164 165 u->ret = test_unwind(NULL, (u->flags & UWM_REGS) ? regs : NULL, 166 (u->flags & UWM_SP) ? u->sp : 0); 167 168 return 0; 169 } 170 171 static noinline notrace int test_unwind_kretprobed_func(struct unwindme *u) 172 { 173 struct pt_regs regs; 174 175 if (!(u->flags & UWM_KRETPROBE)) 176 return 0; 177 178 regs = fake_pt_regs(); 179 return test_unwind(NULL, (u->flags & UWM_REGS) ? ®s : NULL, 180 (u->flags & UWM_SP) ? u->sp : 0); 181 } 182 183 static noinline int test_unwind_kretprobed_func_caller(struct unwindme *u) 184 { 185 return test_unwind_kretprobed_func(u); 186 } 187 188 static int test_unwind_kretprobe(struct unwindme *u) 189 { 190 int ret; 191 struct kretprobe my_kretprobe; 192 193 if (!IS_ENABLED(CONFIG_KPROBES)) 194 kunit_skip(current_test, "requires CONFIG_KPROBES"); 195 196 u->ret = -1; /* make sure kprobe is called */ 197 unwindme = u; 198 199 memset(&my_kretprobe, 0, sizeof(my_kretprobe)); 200 my_kretprobe.handler = kretprobe_ret_handler; 201 my_kretprobe.maxactive = 1; 202 my_kretprobe.kp.addr = (kprobe_opcode_t *)test_unwind_kretprobed_func; 203 204 ret = register_kretprobe(&my_kretprobe); 205 206 if (ret < 0) { 207 kunit_err(current_test, "register_kretprobe failed %d\n", ret); 208 return -EINVAL; 209 } 210 211 ret = test_unwind_kretprobed_func_caller(u); 212 unregister_kretprobe(&my_kretprobe); 213 unwindme = NULL; 214 if (u->flags & UWM_KRETPROBE_HANDLER) 215 ret = u->ret; 216 return ret; 217 } 218 219 static int kprobe_pre_handler(struct kprobe *p, struct pt_regs *regs) 220 { 221 struct unwindme *u = unwindme; 222 223 u->ret = test_unwind(NULL, (u->flags & UWM_REGS) ? regs : NULL, 224 (u->flags & UWM_SP) ? u->sp : 0); 225 return 0; 226 } 227 228 extern const char test_unwind_kprobed_insn[]; 229 230 static noinline void test_unwind_kprobed_func(void) 231 { 232 asm volatile( 233 " nopr %%r7\n" 234 "test_unwind_kprobed_insn:\n" 235 " nopr %%r7\n" 236 :); 237 } 238 239 static int test_unwind_kprobe(struct unwindme *u) 240 { 241 struct kprobe kp; 242 int ret; 243 244 if (!IS_ENABLED(CONFIG_KPROBES)) 245 kunit_skip(current_test, "requires CONFIG_KPROBES"); 246 if (!IS_ENABLED(CONFIG_KPROBES_ON_FTRACE) && u->flags & UWM_KPROBE_ON_FTRACE) 247 kunit_skip(current_test, "requires CONFIG_KPROBES_ON_FTRACE"); 248 249 u->ret = -1; /* make sure kprobe is called */ 250 unwindme = u; 251 memset(&kp, 0, sizeof(kp)); 252 kp.pre_handler = kprobe_pre_handler; 253 kp.addr = u->flags & UWM_KPROBE_ON_FTRACE ? 254 (kprobe_opcode_t *)test_unwind_kprobed_func : 255 (kprobe_opcode_t *)test_unwind_kprobed_insn; 256 ret = register_kprobe(&kp); 257 if (ret < 0) { 258 kunit_err(current_test, "register_kprobe failed %d\n", ret); 259 return -EINVAL; 260 } 261 262 test_unwind_kprobed_func(); 263 unregister_kprobe(&kp); 264 unwindme = NULL; 265 return u->ret; 266 } 267 268 static void notrace __used test_unwind_ftrace_handler(unsigned long ip, 269 unsigned long parent_ip, 270 struct ftrace_ops *fops, 271 struct ftrace_regs *fregs) 272 { 273 struct unwindme *u = (struct unwindme *)arch_ftrace_regs(fregs)->regs.gprs[2]; 274 275 u->ret = test_unwind(NULL, (u->flags & UWM_REGS) ? &arch_ftrace_regs(fregs)->regs : NULL, 276 (u->flags & UWM_SP) ? u->sp : 0); 277 } 278 279 static noinline int test_unwind_ftraced_func(struct unwindme *u) 280 { 281 return READ_ONCE(u)->ret; 282 } 283 284 static int test_unwind_ftrace(struct unwindme *u) 285 { 286 int ret; 287 #ifdef CONFIG_DYNAMIC_FTRACE 288 struct ftrace_ops *fops; 289 290 fops = kunit_kzalloc(current_test, sizeof(*fops), GFP_KERNEL); 291 fops->func = test_unwind_ftrace_handler; 292 fops->flags = FTRACE_OPS_FL_DYNAMIC | 293 FTRACE_OPS_FL_RECURSION | 294 FTRACE_OPS_FL_SAVE_REGS | 295 FTRACE_OPS_FL_PERMANENT; 296 #else 297 kunit_skip(current_test, "requires CONFIG_DYNAMIC_FTRACE"); 298 #endif 299 300 ret = ftrace_set_filter_ip(fops, (unsigned long)test_unwind_ftraced_func, 0, 0); 301 if (ret) { 302 kunit_err(current_test, "failed to set ftrace filter (%d)\n", ret); 303 return -1; 304 } 305 306 ret = register_ftrace_function(fops); 307 if (!ret) { 308 ret = test_unwind_ftraced_func(u); 309 unregister_ftrace_function(fops); 310 } else { 311 kunit_err(current_test, "failed to register ftrace handler (%d)\n", ret); 312 } 313 314 ftrace_set_filter_ip(fops, (unsigned long)test_unwind_ftraced_func, 1, 0); 315 return ret; 316 } 317 318 /* This function may or may not appear in the backtrace. */ 319 static noinline int unwindme_func4(struct unwindme *u) 320 { 321 if (!(u->flags & UWM_CALLER)) 322 u->sp = current_frame_address(); 323 if (u->flags & UWM_THREAD) { 324 complete(&u->task_ready); 325 wait_event(u->task_wq, kthread_should_park()); 326 kthread_parkme(); 327 return 0; 328 } else if (u->flags & (UWM_PGM | UWM_KPROBE_ON_FTRACE)) { 329 return test_unwind_kprobe(u); 330 } else if (u->flags & (UWM_KRETPROBE | UWM_KRETPROBE_HANDLER)) { 331 return test_unwind_kretprobe(u); 332 } else if (u->flags & UWM_FTRACE) { 333 return test_unwind_ftrace(u); 334 } else { 335 struct pt_regs regs = fake_pt_regs(); 336 337 return test_unwind(NULL, 338 (u->flags & UWM_REGS) ? ®s : NULL, 339 (u->flags & UWM_SP) ? u->sp : 0); 340 } 341 } 342 343 /* This function may or may not appear in the backtrace. */ 344 static noinline int unwindme_func3(struct unwindme *u) 345 { 346 u->sp = current_frame_address(); 347 return unwindme_func4(u); 348 } 349 350 /* This function must appear in the backtrace. */ 351 static noinline int unwindme_func2(struct unwindme *u) 352 { 353 unsigned long flags, mflags; 354 int rc; 355 356 if (u->flags & UWM_SWITCH_STACK) { 357 local_irq_save(flags); 358 local_mcck_save(mflags); 359 rc = call_on_stack(1, get_lowcore()->nodat_stack, 360 int, unwindme_func3, struct unwindme *, u); 361 local_mcck_restore(mflags); 362 local_irq_restore(flags); 363 return rc; 364 } else { 365 return unwindme_func3(u); 366 } 367 } 368 369 /* This function must follow unwindme_func2 in the backtrace. */ 370 static noinline int unwindme_func1(void *u) 371 { 372 return unwindme_func2((struct unwindme *)u); 373 } 374 375 static void unwindme_timer_fn(struct timer_list *unused) 376 { 377 struct unwindme *u = READ_ONCE(unwindme); 378 379 if (u) { 380 unwindme = NULL; 381 u->task = NULL; 382 u->ret = unwindme_func1(u); 383 complete(&u->task_ready); 384 } 385 } 386 387 static struct timer_list unwind_timer; 388 389 static int test_unwind_irq(struct unwindme *u) 390 { 391 unwindme = u; 392 init_completion(&u->task_ready); 393 timer_setup(&unwind_timer, unwindme_timer_fn, 0); 394 mod_timer(&unwind_timer, jiffies + 1); 395 wait_for_completion(&u->task_ready); 396 return u->ret; 397 } 398 399 /* Spawns a task and passes it to test_unwind(). */ 400 static int test_unwind_task(struct unwindme *u) 401 { 402 struct task_struct *task; 403 int ret; 404 405 /* Initialize thread-related fields. */ 406 init_completion(&u->task_ready); 407 init_waitqueue_head(&u->task_wq); 408 409 /* 410 * Start the task and wait until it reaches unwindme_func4() and sleeps 411 * in (task_ready, unwind_done] range. 412 */ 413 task = kthread_run(unwindme_func1, u, "%s", __func__); 414 if (IS_ERR(task)) { 415 kunit_err(current_test, "kthread_run() failed\n"); 416 return PTR_ERR(task); 417 } 418 /* 419 * Make sure task reaches unwindme_func4 before parking it, 420 * we might park it before kthread function has been executed otherwise 421 */ 422 wait_for_completion(&u->task_ready); 423 kthread_park(task); 424 /* Unwind. */ 425 ret = test_unwind(task, NULL, (u->flags & UWM_SP) ? u->sp : 0); 426 kthread_stop(task); 427 return ret; 428 } 429 430 struct test_params { 431 int flags; 432 char *name; 433 }; 434 435 /* 436 * Create required parameter list for tests 437 */ 438 #define TEST_WITH_FLAGS(f) { .flags = f, .name = #f } 439 static const struct test_params param_list[] = { 440 TEST_WITH_FLAGS(UWM_DEFAULT), 441 TEST_WITH_FLAGS(UWM_SP), 442 TEST_WITH_FLAGS(UWM_REGS), 443 TEST_WITH_FLAGS(UWM_SWITCH_STACK), 444 TEST_WITH_FLAGS(UWM_SP | UWM_REGS), 445 TEST_WITH_FLAGS(UWM_CALLER | UWM_SP), 446 TEST_WITH_FLAGS(UWM_CALLER | UWM_SP | UWM_REGS), 447 TEST_WITH_FLAGS(UWM_CALLER | UWM_SP | UWM_REGS | UWM_SWITCH_STACK), 448 TEST_WITH_FLAGS(UWM_THREAD), 449 TEST_WITH_FLAGS(UWM_THREAD | UWM_SP), 450 TEST_WITH_FLAGS(UWM_THREAD | UWM_CALLER | UWM_SP), 451 TEST_WITH_FLAGS(UWM_IRQ), 452 TEST_WITH_FLAGS(UWM_IRQ | UWM_SWITCH_STACK), 453 TEST_WITH_FLAGS(UWM_IRQ | UWM_SP), 454 TEST_WITH_FLAGS(UWM_IRQ | UWM_REGS), 455 TEST_WITH_FLAGS(UWM_IRQ | UWM_SP | UWM_REGS), 456 TEST_WITH_FLAGS(UWM_IRQ | UWM_CALLER | UWM_SP), 457 TEST_WITH_FLAGS(UWM_IRQ | UWM_CALLER | UWM_SP | UWM_REGS), 458 TEST_WITH_FLAGS(UWM_IRQ | UWM_CALLER | UWM_SP | UWM_REGS | UWM_SWITCH_STACK), 459 TEST_WITH_FLAGS(UWM_PGM), 460 TEST_WITH_FLAGS(UWM_PGM | UWM_SP), 461 TEST_WITH_FLAGS(UWM_PGM | UWM_REGS), 462 TEST_WITH_FLAGS(UWM_PGM | UWM_SP | UWM_REGS), 463 TEST_WITH_FLAGS(UWM_KPROBE_ON_FTRACE), 464 TEST_WITH_FLAGS(UWM_KPROBE_ON_FTRACE | UWM_SP), 465 TEST_WITH_FLAGS(UWM_KPROBE_ON_FTRACE | UWM_REGS), 466 TEST_WITH_FLAGS(UWM_KPROBE_ON_FTRACE | UWM_SP | UWM_REGS), 467 TEST_WITH_FLAGS(UWM_FTRACE), 468 TEST_WITH_FLAGS(UWM_FTRACE | UWM_SP), 469 TEST_WITH_FLAGS(UWM_FTRACE | UWM_REGS), 470 TEST_WITH_FLAGS(UWM_FTRACE | UWM_SP | UWM_REGS), 471 TEST_WITH_FLAGS(UWM_KRETPROBE), 472 TEST_WITH_FLAGS(UWM_KRETPROBE | UWM_SP), 473 TEST_WITH_FLAGS(UWM_KRETPROBE | UWM_REGS), 474 TEST_WITH_FLAGS(UWM_KRETPROBE | UWM_SP | UWM_REGS), 475 TEST_WITH_FLAGS(UWM_KRETPROBE_HANDLER), 476 TEST_WITH_FLAGS(UWM_KRETPROBE_HANDLER | UWM_SP), 477 TEST_WITH_FLAGS(UWM_KRETPROBE_HANDLER | UWM_REGS), 478 TEST_WITH_FLAGS(UWM_KRETPROBE_HANDLER | UWM_SP | UWM_REGS), 479 }; 480 481 /* 482 * Parameter description generator: required for KUNIT_ARRAY_PARAM() 483 */ 484 static void get_desc(const struct test_params *params, char *desc) 485 { 486 strscpy(desc, params->name, KUNIT_PARAM_DESC_SIZE); 487 } 488 489 /* 490 * Create test_unwind_gen_params 491 */ 492 KUNIT_ARRAY_PARAM(test_unwind, param_list, get_desc); 493 494 static void test_unwind_flags(struct kunit *test) 495 { 496 struct unwindme u; 497 const struct test_params *params; 498 499 current_test = test; 500 params = (const struct test_params *)test->param_value; 501 u.flags = params->flags; 502 if (u.flags & UWM_THREAD) 503 KUNIT_EXPECT_EQ(test, 0, test_unwind_task(&u)); 504 else if (u.flags & UWM_IRQ) 505 KUNIT_EXPECT_EQ(test, 0, test_unwind_irq(&u)); 506 else 507 KUNIT_EXPECT_EQ(test, 0, unwindme_func1(&u)); 508 } 509 510 static struct kunit_case unwind_test_cases[] = { 511 KUNIT_CASE_PARAM(test_unwind_flags, test_unwind_gen_params), 512 {} 513 }; 514 515 static struct kunit_suite test_unwind_suite = { 516 .name = "test_unwind", 517 .test_cases = unwind_test_cases, 518 }; 519 520 kunit_test_suites(&test_unwind_suite); 521 522 MODULE_DESCRIPTION("KUnit test for unwind_for_each_frame"); 523 MODULE_LICENSE("GPL"); 524