1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Test module for unwind_for_each_frame 4 */ 5 6 #define pr_fmt(fmt) "test_unwind: " fmt 7 #include <asm/unwind.h> 8 #include <linux/completion.h> 9 #include <linux/kallsyms.h> 10 #include <linux/kthread.h> 11 #include <linux/module.h> 12 #include <linux/timer.h> 13 #include <linux/slab.h> 14 #include <linux/string.h> 15 #include <linux/kprobes.h> 16 #include <linux/wait.h> 17 #include <asm/irq.h> 18 19 #define BT_BUF_SIZE (PAGE_SIZE * 4) 20 21 /* 22 * To avoid printk line limit split backtrace by lines 23 */ 24 static void print_backtrace(char *bt) 25 { 26 char *p; 27 28 while (true) { 29 p = strsep(&bt, "\n"); 30 if (!p) 31 break; 32 pr_err("%s\n", p); 33 } 34 } 35 36 /* 37 * Calls unwind_for_each_frame(task, regs, sp) and verifies that the result 38 * contains unwindme_func2 followed by unwindme_func1. 39 */ 40 static noinline int test_unwind(struct task_struct *task, struct pt_regs *regs, 41 unsigned long sp) 42 { 43 int frame_count, prev_is_func2, seen_func2_func1; 44 const int max_frames = 128; 45 struct unwind_state state; 46 size_t bt_pos = 0; 47 int ret = 0; 48 char *bt; 49 50 bt = kmalloc(BT_BUF_SIZE, GFP_ATOMIC); 51 if (!bt) { 52 pr_err("failed to allocate backtrace buffer\n"); 53 return -ENOMEM; 54 } 55 /* Unwind. */ 56 frame_count = 0; 57 prev_is_func2 = 0; 58 seen_func2_func1 = 0; 59 unwind_for_each_frame(&state, task, regs, sp) { 60 unsigned long addr = unwind_get_return_address(&state); 61 char sym[KSYM_SYMBOL_LEN]; 62 63 if (frame_count++ == max_frames) 64 break; 65 if (state.reliable && !addr) { 66 pr_err("unwind state reliable but addr is 0\n"); 67 ret = -EINVAL; 68 break; 69 } 70 sprint_symbol(sym, addr); 71 if (bt_pos < BT_BUF_SIZE) { 72 bt_pos += snprintf(bt + bt_pos, BT_BUF_SIZE - bt_pos, 73 state.reliable ? " [%-7s%px] %pSR\n" : 74 "([%-7s%px] %pSR)\n", 75 stack_type_name(state.stack_info.type), 76 (void *)state.sp, (void *)state.ip); 77 if (bt_pos >= BT_BUF_SIZE) 78 pr_err("backtrace buffer is too small\n"); 79 } 80 frame_count += 1; 81 if (prev_is_func2 && str_has_prefix(sym, "unwindme_func1")) 82 seen_func2_func1 = 1; 83 prev_is_func2 = str_has_prefix(sym, "unwindme_func2"); 84 } 85 86 /* Check the results. */ 87 if (unwind_error(&state)) { 88 pr_err("unwind error\n"); 89 ret = -EINVAL; 90 } 91 if (!seen_func2_func1) { 92 pr_err("unwindme_func2 and unwindme_func1 not found\n"); 93 ret = -EINVAL; 94 } 95 if (frame_count == max_frames) { 96 pr_err("Maximum number of frames exceeded\n"); 97 ret = -EINVAL; 98 } 99 if (ret) 100 print_backtrace(bt); 101 kfree(bt); 102 return ret; 103 } 104 105 /* State of the task being unwound. */ 106 struct unwindme { 107 int flags; 108 int ret; 109 struct task_struct *task; 110 struct completion task_ready; 111 wait_queue_head_t task_wq; 112 unsigned long sp; 113 }; 114 115 static struct unwindme *unwindme; 116 117 /* Values of unwindme.flags. */ 118 #define UWM_DEFAULT 0x0 119 #define UWM_THREAD 0x1 /* Unwind a separate task. */ 120 #define UWM_REGS 0x2 /* Pass regs to test_unwind(). */ 121 #define UWM_SP 0x4 /* Pass sp to test_unwind(). */ 122 #define UWM_CALLER 0x8 /* Unwind starting from caller. */ 123 #define UWM_SWITCH_STACK 0x10 /* Use call_on_stack. */ 124 #define UWM_IRQ 0x20 /* Unwind from irq context. */ 125 #define UWM_PGM 0x40 /* Unwind from program check handler. */ 126 127 static __always_inline unsigned long get_psw_addr(void) 128 { 129 unsigned long psw_addr; 130 131 asm volatile( 132 "basr %[psw_addr],0\n" 133 : [psw_addr] "=d" (psw_addr)); 134 return psw_addr; 135 } 136 137 #ifdef CONFIG_KPROBES 138 static int pgm_pre_handler(struct kprobe *p, struct pt_regs *regs) 139 { 140 struct unwindme *u = unwindme; 141 142 u->ret = test_unwind(NULL, (u->flags & UWM_REGS) ? regs : NULL, 143 (u->flags & UWM_SP) ? u->sp : 0); 144 return 0; 145 } 146 #endif 147 148 /* This function may or may not appear in the backtrace. */ 149 static noinline int unwindme_func4(struct unwindme *u) 150 { 151 if (!(u->flags & UWM_CALLER)) 152 u->sp = current_frame_address(); 153 if (u->flags & UWM_THREAD) { 154 complete(&u->task_ready); 155 wait_event(u->task_wq, kthread_should_park()); 156 kthread_parkme(); 157 return 0; 158 #ifdef CONFIG_KPROBES 159 } else if (u->flags & UWM_PGM) { 160 struct kprobe kp; 161 int ret; 162 163 unwindme = u; 164 memset(&kp, 0, sizeof(kp)); 165 kp.symbol_name = "do_report_trap"; 166 kp.pre_handler = pgm_pre_handler; 167 ret = register_kprobe(&kp); 168 if (ret < 0) { 169 pr_err("register_kprobe failed %d\n", ret); 170 return -EINVAL; 171 } 172 173 /* 174 * trigger specification exception 175 */ 176 asm volatile( 177 " mvcl %%r1,%%r1\n" 178 "0: nopr %%r7\n" 179 EX_TABLE(0b, 0b) 180 :); 181 182 unregister_kprobe(&kp); 183 unwindme = NULL; 184 return u->ret; 185 #endif 186 } else { 187 struct pt_regs regs; 188 189 memset(®s, 0, sizeof(regs)); 190 regs.psw.addr = get_psw_addr(); 191 regs.gprs[15] = current_stack_pointer(); 192 return test_unwind(NULL, 193 (u->flags & UWM_REGS) ? ®s : NULL, 194 (u->flags & UWM_SP) ? u->sp : 0); 195 } 196 } 197 198 /* This function may or may not appear in the backtrace. */ 199 static noinline int unwindme_func3(struct unwindme *u) 200 { 201 u->sp = current_frame_address(); 202 return unwindme_func4(u); 203 } 204 205 /* This function must appear in the backtrace. */ 206 static noinline int unwindme_func2(struct unwindme *u) 207 { 208 unsigned long flags; 209 int rc; 210 211 if (u->flags & UWM_SWITCH_STACK) { 212 local_irq_save(flags); 213 local_mcck_disable(); 214 rc = call_on_stack(1, S390_lowcore.nodat_stack, 215 int, unwindme_func3, struct unwindme *, u); 216 local_mcck_enable(); 217 local_irq_restore(flags); 218 return rc; 219 } else { 220 return unwindme_func3(u); 221 } 222 } 223 224 /* This function must follow unwindme_func2 in the backtrace. */ 225 static noinline int unwindme_func1(void *u) 226 { 227 return unwindme_func2((struct unwindme *)u); 228 } 229 230 static void unwindme_timer_fn(struct timer_list *unused) 231 { 232 struct unwindme *u = READ_ONCE(unwindme); 233 234 if (u) { 235 unwindme = NULL; 236 u->task = NULL; 237 u->ret = unwindme_func1(u); 238 complete(&u->task_ready); 239 } 240 } 241 242 static struct timer_list unwind_timer; 243 244 static int test_unwind_irq(struct unwindme *u) 245 { 246 unwindme = u; 247 init_completion(&u->task_ready); 248 timer_setup(&unwind_timer, unwindme_timer_fn, 0); 249 mod_timer(&unwind_timer, jiffies + 1); 250 wait_for_completion(&u->task_ready); 251 return u->ret; 252 } 253 254 /* Spawns a task and passes it to test_unwind(). */ 255 static int test_unwind_task(struct unwindme *u) 256 { 257 struct task_struct *task; 258 int ret; 259 260 /* Initialize thread-related fields. */ 261 init_completion(&u->task_ready); 262 init_waitqueue_head(&u->task_wq); 263 264 /* 265 * Start the task and wait until it reaches unwindme_func4() and sleeps 266 * in (task_ready, unwind_done] range. 267 */ 268 task = kthread_run(unwindme_func1, u, "%s", __func__); 269 if (IS_ERR(task)) { 270 pr_err("kthread_run() failed\n"); 271 return PTR_ERR(task); 272 } 273 /* 274 * Make sure task reaches unwindme_func4 before parking it, 275 * we might park it before kthread function has been executed otherwise 276 */ 277 wait_for_completion(&u->task_ready); 278 kthread_park(task); 279 /* Unwind. */ 280 ret = test_unwind(task, NULL, (u->flags & UWM_SP) ? u->sp : 0); 281 kthread_stop(task); 282 return ret; 283 } 284 285 static int test_unwind_flags(int flags) 286 { 287 struct unwindme u; 288 289 u.flags = flags; 290 if (u.flags & UWM_THREAD) 291 return test_unwind_task(&u); 292 else if (u.flags & UWM_IRQ) 293 return test_unwind_irq(&u); 294 else 295 return unwindme_func1(&u); 296 } 297 298 static int test_unwind_init(void) 299 { 300 int failed = 0; 301 int total = 0; 302 303 #define TEST(flags) \ 304 do { \ 305 pr_info("[ RUN ] " #flags "\n"); \ 306 total++; \ 307 if (!test_unwind_flags((flags))) { \ 308 pr_info("[ OK ] " #flags "\n"); \ 309 } else { \ 310 pr_err("[ FAILED ] " #flags "\n"); \ 311 failed++; \ 312 } \ 313 } while (0) 314 315 pr_info("running stack unwinder tests"); 316 TEST(UWM_DEFAULT); 317 TEST(UWM_SP); 318 TEST(UWM_REGS); 319 TEST(UWM_SWITCH_STACK); 320 TEST(UWM_SP | UWM_REGS); 321 TEST(UWM_CALLER | UWM_SP); 322 TEST(UWM_CALLER | UWM_SP | UWM_REGS); 323 TEST(UWM_CALLER | UWM_SP | UWM_REGS | UWM_SWITCH_STACK); 324 TEST(UWM_THREAD); 325 TEST(UWM_THREAD | UWM_SP); 326 TEST(UWM_THREAD | UWM_CALLER | UWM_SP); 327 TEST(UWM_IRQ); 328 TEST(UWM_IRQ | UWM_SWITCH_STACK); 329 TEST(UWM_IRQ | UWM_SP); 330 TEST(UWM_IRQ | UWM_REGS); 331 TEST(UWM_IRQ | UWM_SP | UWM_REGS); 332 TEST(UWM_IRQ | UWM_CALLER | UWM_SP); 333 TEST(UWM_IRQ | UWM_CALLER | UWM_SP | UWM_REGS); 334 TEST(UWM_IRQ | UWM_CALLER | UWM_SP | UWM_REGS | UWM_SWITCH_STACK); 335 #ifdef CONFIG_KPROBES 336 TEST(UWM_PGM); 337 TEST(UWM_PGM | UWM_SP); 338 TEST(UWM_PGM | UWM_REGS); 339 TEST(UWM_PGM | UWM_SP | UWM_REGS); 340 #endif 341 #undef TEST 342 if (failed) { 343 pr_err("%d of %d stack unwinder tests failed", failed, total); 344 WARN(1, "%d of %d stack unwinder tests failed", failed, total); 345 } else { 346 pr_info("all %d stack unwinder tests passed", total); 347 } 348 349 return failed ? -EINVAL : 0; 350 } 351 352 static void test_unwind_exit(void) 353 { 354 } 355 356 module_init(test_unwind_init); 357 module_exit(test_unwind_exit); 358 MODULE_LICENSE("GPL"); 359