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