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 <linux/kprobes.h> 17 #include <linux/kdebug.h> 18 #include <linux/extable.h> 19 #include <linux/ptrace.h> 20 #include <linux/sched.h> 21 #include <linux/sched/debug.h> 22 #include <linux/mm.h> 23 #include <linux/slab.h> 24 #include <linux/uaccess.h> 25 #include <linux/cpu.h> 26 #include <asm/fpu/api.h> 27 #include "entry.h" 28 29 static inline void __user *get_trap_ip(struct pt_regs *regs) 30 { 31 unsigned long address; 32 33 if (regs->int_code & 0x200) 34 address = *(unsigned long *)(current->thread.trap_tdb + 24); 35 else 36 address = regs->psw.addr; 37 return (void __user *) (address - (regs->int_code >> 16)); 38 } 39 40 int is_valid_bugaddr(unsigned long addr) 41 { 42 return 1; 43 } 44 45 void do_report_trap(struct pt_regs *regs, int si_signo, int si_code, char *str) 46 { 47 siginfo_t info; 48 49 if (user_mode(regs)) { 50 info.si_signo = si_signo; 51 info.si_errno = 0; 52 info.si_code = si_code; 53 info.si_addr = get_trap_ip(regs); 54 force_sig_info(si_signo, &info, current); 55 report_user_fault(regs, si_signo, 0); 56 } else { 57 const struct exception_table_entry *fixup; 58 fixup = search_exception_tables(regs->psw.addr); 59 if (fixup) 60 regs->psw.addr = extable_fixup(fixup); 61 else { 62 enum bug_trap_type btt; 63 64 btt = report_bug(regs->psw.addr, regs); 65 if (btt == BUG_TRAP_TYPE_WARN) 66 return; 67 die(regs, str); 68 } 69 } 70 } 71 72 static void do_trap(struct pt_regs *regs, int si_signo, int si_code, char *str) 73 { 74 if (notify_die(DIE_TRAP, str, regs, 0, 75 regs->int_code, si_signo) == NOTIFY_STOP) 76 return; 77 do_report_trap(regs, si_signo, si_code, str); 78 } 79 NOKPROBE_SYMBOL(do_trap); 80 81 void do_per_trap(struct pt_regs *regs) 82 { 83 siginfo_t info; 84 85 if (notify_die(DIE_SSTEP, "sstep", regs, 0, 0, SIGTRAP) == NOTIFY_STOP) 86 return; 87 if (!current->ptrace) 88 return; 89 info.si_signo = SIGTRAP; 90 info.si_errno = 0; 91 info.si_code = TRAP_HWBKPT; 92 info.si_addr = 93 (void __force __user *) current->thread.per_event.address; 94 force_sig_info(SIGTRAP, &info, current); 95 } 96 NOKPROBE_SYMBOL(do_per_trap); 97 98 void default_trap_handler(struct pt_regs *regs) 99 { 100 if (user_mode(regs)) { 101 report_user_fault(regs, SIGSEGV, 0); 102 do_exit(SIGSEGV); 103 } else 104 die(regs, "Unknown program exception"); 105 } 106 107 #define DO_ERROR_INFO(name, signr, sicode, str) \ 108 void name(struct pt_regs *regs) \ 109 { \ 110 do_trap(regs, signr, sicode, str); \ 111 } 112 113 DO_ERROR_INFO(addressing_exception, SIGILL, ILL_ILLADR, 114 "addressing exception") 115 DO_ERROR_INFO(execute_exception, SIGILL, ILL_ILLOPN, 116 "execute exception") 117 DO_ERROR_INFO(divide_exception, SIGFPE, FPE_INTDIV, 118 "fixpoint divide exception") 119 DO_ERROR_INFO(overflow_exception, SIGFPE, FPE_INTOVF, 120 "fixpoint overflow exception") 121 DO_ERROR_INFO(hfp_overflow_exception, SIGFPE, FPE_FLTOVF, 122 "HFP overflow exception") 123 DO_ERROR_INFO(hfp_underflow_exception, SIGFPE, FPE_FLTUND, 124 "HFP underflow exception") 125 DO_ERROR_INFO(hfp_significance_exception, SIGFPE, FPE_FLTRES, 126 "HFP significance exception") 127 DO_ERROR_INFO(hfp_divide_exception, SIGFPE, FPE_FLTDIV, 128 "HFP divide exception") 129 DO_ERROR_INFO(hfp_sqrt_exception, SIGFPE, FPE_FLTINV, 130 "HFP square root exception") 131 DO_ERROR_INFO(operand_exception, SIGILL, ILL_ILLOPN, 132 "operand exception") 133 DO_ERROR_INFO(privileged_op, SIGILL, ILL_PRVOPC, 134 "privileged operation") 135 DO_ERROR_INFO(special_op_exception, SIGILL, ILL_ILLOPN, 136 "special operation exception") 137 DO_ERROR_INFO(transaction_exception, SIGILL, ILL_ILLOPN, 138 "transaction constraint exception") 139 140 static inline void do_fp_trap(struct pt_regs *regs, __u32 fpc) 141 { 142 int si_code = 0; 143 /* FPC[2] is Data Exception Code */ 144 if ((fpc & 0x00000300) == 0) { 145 /* bits 6 and 7 of DXC are 0 iff IEEE exception */ 146 if (fpc & 0x8000) /* invalid fp operation */ 147 si_code = FPE_FLTINV; 148 else if (fpc & 0x4000) /* div by 0 */ 149 si_code = FPE_FLTDIV; 150 else if (fpc & 0x2000) /* overflow */ 151 si_code = FPE_FLTOVF; 152 else if (fpc & 0x1000) /* underflow */ 153 si_code = FPE_FLTUND; 154 else if (fpc & 0x0800) /* inexact */ 155 si_code = FPE_FLTRES; 156 } 157 do_trap(regs, SIGFPE, si_code, "floating point exception"); 158 } 159 160 void translation_exception(struct pt_regs *regs) 161 { 162 /* May never happen. */ 163 panic("Translation exception"); 164 } 165 166 void illegal_op(struct pt_regs *regs) 167 { 168 siginfo_t info; 169 __u8 opcode[6]; 170 __u16 __user *location; 171 int is_uprobe_insn = 0; 172 int signal = 0; 173 174 location = get_trap_ip(regs); 175 176 if (user_mode(regs)) { 177 if (get_user(*((__u16 *) opcode), (__u16 __user *) location)) 178 return; 179 if (*((__u16 *) opcode) == S390_BREAKPOINT_U16) { 180 if (current->ptrace) { 181 info.si_signo = SIGTRAP; 182 info.si_errno = 0; 183 info.si_code = TRAP_BRKPT; 184 info.si_addr = location; 185 force_sig_info(SIGTRAP, &info, current); 186 } else 187 signal = SIGILL; 188 #ifdef CONFIG_UPROBES 189 } else if (*((__u16 *) opcode) == UPROBE_SWBP_INSN) { 190 is_uprobe_insn = 1; 191 #endif 192 } else 193 signal = SIGILL; 194 } 195 /* 196 * We got either an illegal op in kernel mode, or user space trapped 197 * on a uprobes illegal instruction. See if kprobes or uprobes picks 198 * it up. If not, SIGILL. 199 */ 200 if (is_uprobe_insn || !user_mode(regs)) { 201 if (notify_die(DIE_BPT, "bpt", regs, 0, 202 3, SIGTRAP) != NOTIFY_STOP) 203 signal = SIGILL; 204 } 205 if (signal) 206 do_trap(regs, signal, ILL_ILLOPC, "illegal operation"); 207 } 208 NOKPROBE_SYMBOL(illegal_op); 209 210 DO_ERROR_INFO(specification_exception, SIGILL, ILL_ILLOPN, 211 "specification exception"); 212 213 void vector_exception(struct pt_regs *regs) 214 { 215 int si_code, vic; 216 217 if (!MACHINE_HAS_VX) { 218 do_trap(regs, SIGILL, ILL_ILLOPN, "illegal operation"); 219 return; 220 } 221 222 /* get vector interrupt code from fpc */ 223 save_fpu_regs(); 224 vic = (current->thread.fpu.fpc & 0xf00) >> 8; 225 switch (vic) { 226 case 1: /* invalid vector operation */ 227 si_code = FPE_FLTINV; 228 break; 229 case 2: /* division by zero */ 230 si_code = FPE_FLTDIV; 231 break; 232 case 3: /* overflow */ 233 si_code = FPE_FLTOVF; 234 break; 235 case 4: /* underflow */ 236 si_code = FPE_FLTUND; 237 break; 238 case 5: /* inexact */ 239 si_code = FPE_FLTRES; 240 break; 241 default: /* unknown cause */ 242 si_code = 0; 243 } 244 do_trap(regs, SIGFPE, si_code, "vector exception"); 245 } 246 247 void data_exception(struct pt_regs *regs) 248 { 249 int signal = 0; 250 251 save_fpu_regs(); 252 if (current->thread.fpu.fpc & FPC_DXC_MASK) 253 signal = SIGFPE; 254 else 255 signal = SIGILL; 256 if (signal == SIGFPE) 257 do_fp_trap(regs, current->thread.fpu.fpc); 258 else if (signal) 259 do_trap(regs, signal, ILL_ILLOPN, "data exception"); 260 } 261 262 void space_switch_exception(struct pt_regs *regs) 263 { 264 /* Set user psw back to home space mode. */ 265 if (user_mode(regs)) 266 regs->psw.mask |= PSW_ASC_HOME; 267 /* Send SIGILL. */ 268 do_trap(regs, SIGILL, ILL_PRVOPC, "space switch event"); 269 } 270 271 void kernel_stack_overflow(struct pt_regs *regs) 272 { 273 bust_spinlocks(1); 274 printk("Kernel stack overflow.\n"); 275 show_regs(regs); 276 bust_spinlocks(0); 277 panic("Corrupt kernel stack, can't continue."); 278 } 279 NOKPROBE_SYMBOL(kernel_stack_overflow); 280 281 void __init trap_init(void) 282 { 283 local_mcck_enable(); 284 } 285