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