1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * S390 version 4 * Copyright IBM Corp. 1999, 2000 5 * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com), 6 * Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com), 7 * 8 * Derived from "arch/i386/kernel/traps.c" 9 * Copyright (C) 1991, 1992 Linus Torvalds 10 */ 11 12 /* 13 * 'Traps.c' handles hardware traps and faults after we have saved some 14 * state in 'asm.s'. 15 */ 16 #include "asm/irqflags.h" 17 #include "asm/ptrace.h" 18 #include <linux/kprobes.h> 19 #include <linux/kdebug.h> 20 #include <linux/randomize_kstack.h> 21 #include <linux/extable.h> 22 #include <linux/ptrace.h> 23 #include <linux/sched.h> 24 #include <linux/sched/debug.h> 25 #include <linux/mm.h> 26 #include <linux/slab.h> 27 #include <linux/uaccess.h> 28 #include <linux/cpu.h> 29 #include <linux/entry-common.h> 30 #include <asm/fpu/api.h> 31 #include <asm/vtime.h> 32 #include "entry.h" 33 34 static inline void __user *get_trap_ip(struct pt_regs *regs) 35 { 36 unsigned long address; 37 38 if (regs->int_code & 0x200) 39 address = current->thread.trap_tdb.data[3]; 40 else 41 address = regs->psw.addr; 42 return (void __user *) (address - (regs->int_code >> 16)); 43 } 44 45 int is_valid_bugaddr(unsigned long addr) 46 { 47 return 1; 48 } 49 50 void do_report_trap(struct pt_regs *regs, int si_signo, int si_code, char *str) 51 { 52 if (user_mode(regs)) { 53 force_sig_fault(si_signo, si_code, get_trap_ip(regs)); 54 report_user_fault(regs, si_signo, 0); 55 } else { 56 const struct exception_table_entry *fixup; 57 fixup = s390_search_extables(regs->psw.addr); 58 if (!fixup || !ex_handle(fixup, regs)) 59 die(regs, str); 60 } 61 } 62 63 static void do_trap(struct pt_regs *regs, int si_signo, int si_code, char *str) 64 { 65 if (notify_die(DIE_TRAP, str, regs, 0, 66 regs->int_code, si_signo) == NOTIFY_STOP) 67 return; 68 do_report_trap(regs, si_signo, si_code, str); 69 } 70 NOKPROBE_SYMBOL(do_trap); 71 72 void do_per_trap(struct pt_regs *regs) 73 { 74 if (notify_die(DIE_SSTEP, "sstep", regs, 0, 0, SIGTRAP) == NOTIFY_STOP) 75 return; 76 if (!current->ptrace) 77 return; 78 force_sig_fault(SIGTRAP, TRAP_HWBKPT, 79 (void __force __user *) current->thread.per_event.address); 80 } 81 NOKPROBE_SYMBOL(do_per_trap); 82 83 static void default_trap_handler(struct pt_regs *regs) 84 { 85 if (user_mode(regs)) { 86 report_user_fault(regs, SIGSEGV, 0); 87 do_exit(SIGSEGV); 88 } else 89 die(regs, "Unknown program exception"); 90 } 91 92 #define DO_ERROR_INFO(name, signr, sicode, str) \ 93 static void name(struct pt_regs *regs) \ 94 { \ 95 do_trap(regs, signr, sicode, str); \ 96 } 97 98 DO_ERROR_INFO(addressing_exception, SIGILL, ILL_ILLADR, 99 "addressing exception") 100 DO_ERROR_INFO(execute_exception, SIGILL, ILL_ILLOPN, 101 "execute exception") 102 DO_ERROR_INFO(divide_exception, SIGFPE, FPE_INTDIV, 103 "fixpoint divide exception") 104 DO_ERROR_INFO(overflow_exception, SIGFPE, FPE_INTOVF, 105 "fixpoint overflow exception") 106 DO_ERROR_INFO(hfp_overflow_exception, SIGFPE, FPE_FLTOVF, 107 "HFP overflow exception") 108 DO_ERROR_INFO(hfp_underflow_exception, SIGFPE, FPE_FLTUND, 109 "HFP underflow exception") 110 DO_ERROR_INFO(hfp_significance_exception, SIGFPE, FPE_FLTRES, 111 "HFP significance exception") 112 DO_ERROR_INFO(hfp_divide_exception, SIGFPE, FPE_FLTDIV, 113 "HFP divide exception") 114 DO_ERROR_INFO(hfp_sqrt_exception, SIGFPE, FPE_FLTINV, 115 "HFP square root exception") 116 DO_ERROR_INFO(operand_exception, SIGILL, ILL_ILLOPN, 117 "operand exception") 118 DO_ERROR_INFO(privileged_op, SIGILL, ILL_PRVOPC, 119 "privileged operation") 120 DO_ERROR_INFO(special_op_exception, SIGILL, ILL_ILLOPN, 121 "special operation exception") 122 DO_ERROR_INFO(transaction_exception, SIGILL, ILL_ILLOPN, 123 "transaction constraint exception") 124 125 static inline void do_fp_trap(struct pt_regs *regs, __u32 fpc) 126 { 127 int si_code = 0; 128 /* FPC[2] is Data Exception Code */ 129 if ((fpc & 0x00000300) == 0) { 130 /* bits 6 and 7 of DXC are 0 iff IEEE exception */ 131 if (fpc & 0x8000) /* invalid fp operation */ 132 si_code = FPE_FLTINV; 133 else if (fpc & 0x4000) /* div by 0 */ 134 si_code = FPE_FLTDIV; 135 else if (fpc & 0x2000) /* overflow */ 136 si_code = FPE_FLTOVF; 137 else if (fpc & 0x1000) /* underflow */ 138 si_code = FPE_FLTUND; 139 else if (fpc & 0x0800) /* inexact */ 140 si_code = FPE_FLTRES; 141 } 142 do_trap(regs, SIGFPE, si_code, "floating point exception"); 143 } 144 145 static void translation_exception(struct pt_regs *regs) 146 { 147 /* May never happen. */ 148 panic("Translation exception"); 149 } 150 151 static void illegal_op(struct pt_regs *regs) 152 { 153 __u8 opcode[6]; 154 __u16 __user *location; 155 int is_uprobe_insn = 0; 156 int signal = 0; 157 158 location = get_trap_ip(regs); 159 160 if (user_mode(regs)) { 161 if (get_user(*((__u16 *) opcode), (__u16 __user *) location)) 162 return; 163 if (*((__u16 *) opcode) == S390_BREAKPOINT_U16) { 164 if (current->ptrace) 165 force_sig_fault(SIGTRAP, TRAP_BRKPT, location); 166 else 167 signal = SIGILL; 168 #ifdef CONFIG_UPROBES 169 } else if (*((__u16 *) opcode) == UPROBE_SWBP_INSN) { 170 is_uprobe_insn = 1; 171 #endif 172 } else 173 signal = SIGILL; 174 } 175 /* 176 * We got either an illegal op in kernel mode, or user space trapped 177 * on a uprobes illegal instruction. See if kprobes or uprobes picks 178 * it up. If not, SIGILL. 179 */ 180 if (is_uprobe_insn || !user_mode(regs)) { 181 if (notify_die(DIE_BPT, "bpt", regs, 0, 182 3, SIGTRAP) != NOTIFY_STOP) 183 signal = SIGILL; 184 } 185 if (signal) 186 do_trap(regs, signal, ILL_ILLOPC, "illegal operation"); 187 } 188 NOKPROBE_SYMBOL(illegal_op); 189 190 DO_ERROR_INFO(specification_exception, SIGILL, ILL_ILLOPN, 191 "specification exception"); 192 193 static void vector_exception(struct pt_regs *regs) 194 { 195 int si_code, vic; 196 197 if (!MACHINE_HAS_VX) { 198 do_trap(regs, SIGILL, ILL_ILLOPN, "illegal operation"); 199 return; 200 } 201 202 /* get vector interrupt code from fpc */ 203 save_fpu_regs(); 204 vic = (current->thread.fpu.fpc & 0xf00) >> 8; 205 switch (vic) { 206 case 1: /* invalid vector operation */ 207 si_code = FPE_FLTINV; 208 break; 209 case 2: /* division by zero */ 210 si_code = FPE_FLTDIV; 211 break; 212 case 3: /* overflow */ 213 si_code = FPE_FLTOVF; 214 break; 215 case 4: /* underflow */ 216 si_code = FPE_FLTUND; 217 break; 218 case 5: /* inexact */ 219 si_code = FPE_FLTRES; 220 break; 221 default: /* unknown cause */ 222 si_code = 0; 223 } 224 do_trap(regs, SIGFPE, si_code, "vector exception"); 225 } 226 227 static void data_exception(struct pt_regs *regs) 228 { 229 save_fpu_regs(); 230 if (current->thread.fpu.fpc & FPC_DXC_MASK) 231 do_fp_trap(regs, current->thread.fpu.fpc); 232 else 233 do_trap(regs, SIGILL, ILL_ILLOPN, "data exception"); 234 } 235 236 static void space_switch_exception(struct pt_regs *regs) 237 { 238 /* Set user psw back to home space mode. */ 239 if (user_mode(regs)) 240 regs->psw.mask |= PSW_ASC_HOME; 241 /* Send SIGILL. */ 242 do_trap(regs, SIGILL, ILL_PRVOPC, "space switch event"); 243 } 244 245 static void monitor_event_exception(struct pt_regs *regs) 246 { 247 const struct exception_table_entry *fixup; 248 249 if (user_mode(regs)) 250 return; 251 252 switch (report_bug(regs->psw.addr - (regs->int_code >> 16), regs)) { 253 case BUG_TRAP_TYPE_NONE: 254 fixup = s390_search_extables(regs->psw.addr); 255 if (fixup) 256 ex_handle(fixup, regs); 257 break; 258 case BUG_TRAP_TYPE_WARN: 259 break; 260 case BUG_TRAP_TYPE_BUG: 261 die(regs, "monitor event"); 262 break; 263 } 264 } 265 266 void kernel_stack_overflow(struct pt_regs *regs) 267 { 268 bust_spinlocks(1); 269 printk("Kernel stack overflow.\n"); 270 show_regs(regs); 271 bust_spinlocks(0); 272 panic("Corrupt kernel stack, can't continue."); 273 } 274 NOKPROBE_SYMBOL(kernel_stack_overflow); 275 276 static void __init test_monitor_call(void) 277 { 278 int val = 1; 279 280 if (!IS_ENABLED(CONFIG_BUG)) 281 return; 282 asm volatile( 283 " mc 0,0\n" 284 "0: xgr %0,%0\n" 285 "1:\n" 286 EX_TABLE(0b,1b) 287 : "+d" (val)); 288 if (!val) 289 panic("Monitor call doesn't work!\n"); 290 } 291 292 void __init trap_init(void) 293 { 294 sort_extable(__start_dma_ex_table, __stop_dma_ex_table); 295 local_mcck_enable(); 296 test_monitor_call(); 297 } 298 299 static void (*pgm_check_table[128])(struct pt_regs *regs); 300 301 void noinstr __do_pgm_check(struct pt_regs *regs) 302 { 303 unsigned long last_break = S390_lowcore.breaking_event_addr; 304 unsigned int trapnr; 305 irqentry_state_t state; 306 307 regs->int_code = *(u32 *)&S390_lowcore.pgm_ilc; 308 regs->int_parm_long = S390_lowcore.trans_exc_code; 309 310 state = irqentry_enter(regs); 311 312 if (user_mode(regs)) { 313 update_timer_sys(); 314 if (last_break < 4096) 315 last_break = 1; 316 current->thread.last_break = last_break; 317 regs->args[0] = last_break; 318 } 319 320 if (S390_lowcore.pgm_code & 0x0200) { 321 /* transaction abort */ 322 current->thread.trap_tdb = S390_lowcore.pgm_tdb; 323 } 324 325 if (S390_lowcore.pgm_code & PGM_INT_CODE_PER) { 326 if (user_mode(regs)) { 327 struct per_event *ev = ¤t->thread.per_event; 328 329 set_thread_flag(TIF_PER_TRAP); 330 ev->address = S390_lowcore.per_address; 331 ev->cause = *(u16 *)&S390_lowcore.per_code; 332 ev->paid = S390_lowcore.per_access_id; 333 } else { 334 /* PER event in kernel is kprobes */ 335 __arch_local_irq_ssm(regs->psw.mask & ~PSW_MASK_PER); 336 do_per_trap(regs); 337 goto out; 338 } 339 } 340 341 if (!irqs_disabled_flags(regs->psw.mask)) 342 trace_hardirqs_on(); 343 __arch_local_irq_ssm(regs->psw.mask & ~PSW_MASK_PER); 344 345 trapnr = regs->int_code & PGM_INT_CODE_MASK; 346 if (trapnr) 347 pgm_check_table[trapnr](regs); 348 out: 349 local_irq_disable(); 350 irqentry_exit(regs, state); 351 } 352 353 /* 354 * The program check table contains exactly 128 (0x00-0x7f) entries. Each 355 * line defines the function to be called corresponding to the program check 356 * interruption code. 357 */ 358 static void (*pgm_check_table[128])(struct pt_regs *regs) = { 359 [0x00] = default_trap_handler, 360 [0x01] = illegal_op, 361 [0x02] = privileged_op, 362 [0x03] = execute_exception, 363 [0x04] = do_protection_exception, 364 [0x05] = addressing_exception, 365 [0x06] = specification_exception, 366 [0x07] = data_exception, 367 [0x08] = overflow_exception, 368 [0x09] = divide_exception, 369 [0x0a] = overflow_exception, 370 [0x0b] = divide_exception, 371 [0x0c] = hfp_overflow_exception, 372 [0x0d] = hfp_underflow_exception, 373 [0x0e] = hfp_significance_exception, 374 [0x0f] = hfp_divide_exception, 375 [0x10] = do_dat_exception, 376 [0x11] = do_dat_exception, 377 [0x12] = translation_exception, 378 [0x13] = special_op_exception, 379 [0x14] = default_trap_handler, 380 [0x15] = operand_exception, 381 [0x16] = default_trap_handler, 382 [0x17] = default_trap_handler, 383 [0x18] = transaction_exception, 384 [0x19] = default_trap_handler, 385 [0x1a] = default_trap_handler, 386 [0x1b] = vector_exception, 387 [0x1c] = space_switch_exception, 388 [0x1d] = hfp_sqrt_exception, 389 [0x1e ... 0x37] = default_trap_handler, 390 [0x38] = do_dat_exception, 391 [0x39] = do_dat_exception, 392 [0x3a] = do_dat_exception, 393 [0x3b] = do_dat_exception, 394 [0x3c] = default_trap_handler, 395 [0x3d] = do_secure_storage_access, 396 [0x3e] = do_non_secure_storage_access, 397 [0x3f] = do_secure_storage_violation, 398 [0x40] = monitor_event_exception, 399 [0x41 ... 0x7f] = default_trap_handler, 400 }; 401 402 #define COND_TRAP(x) asm( \ 403 ".weak " __stringify(x) "\n\t" \ 404 ".set " __stringify(x) "," \ 405 __stringify(default_trap_handler)) 406 407 COND_TRAP(do_secure_storage_access); 408 COND_TRAP(do_non_secure_storage_access); 409 COND_TRAP(do_secure_storage_violation); 410