]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - arch/s390/kernel/traps.c
e9b063e7d75f6b03826439184a4c117e0bc14b87
[~shefty/rdma-dev.git] / arch / s390 / kernel / traps.c
1 /*
2  *  arch/s390/kernel/traps.c
3  *
4  *  S390 version
5  *    Copyright (C) 1999,2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
6  *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
7  *               Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com),
8  *
9  *  Derived from "arch/i386/kernel/traps.c"
10  *    Copyright (C) 1991, 1992 Linus Torvalds
11  */
12
13 /*
14  * 'Traps.c' handles hardware traps and faults after we have saved some
15  * state in 'asm.s'.
16  */
17 #include <linux/sched.h>
18 #include <linux/kernel.h>
19 #include <linux/string.h>
20 #include <linux/errno.h>
21 #include <linux/tracehook.h>
22 #include <linux/timer.h>
23 #include <linux/mm.h>
24 #include <linux/smp.h>
25 #include <linux/init.h>
26 #include <linux/interrupt.h>
27 #include <linux/seq_file.h>
28 #include <linux/delay.h>
29 #include <linux/module.h>
30 #include <linux/kdebug.h>
31 #include <linux/kallsyms.h>
32 #include <linux/reboot.h>
33 #include <linux/kprobes.h>
34 #include <linux/bug.h>
35 #include <linux/utsname.h>
36 #include <asm/system.h>
37 #include <asm/uaccess.h>
38 #include <asm/io.h>
39 #include <asm/atomic.h>
40 #include <asm/mathemu.h>
41 #include <asm/cpcmd.h>
42 #include <asm/s390_ext.h>
43 #include <asm/lowcore.h>
44 #include <asm/debug.h>
45 #include "entry.h"
46
47 pgm_check_handler_t *pgm_check_table[128];
48
49 int show_unhandled_signals;
50
51 extern pgm_check_handler_t do_protection_exception;
52 extern pgm_check_handler_t do_dat_exception;
53 extern pgm_check_handler_t do_asce_exception;
54
55 #define stack_pointer ({ void **sp; asm("la %0,0(15)" : "=&d" (sp)); sp; })
56
57 #ifndef CONFIG_64BIT
58 #define LONG "%08lx "
59 #define FOURLONG "%08lx %08lx %08lx %08lx\n"
60 static int kstack_depth_to_print = 12;
61 #else /* CONFIG_64BIT */
62 #define LONG "%016lx "
63 #define FOURLONG "%016lx %016lx %016lx %016lx\n"
64 static int kstack_depth_to_print = 20;
65 #endif /* CONFIG_64BIT */
66
67 /*
68  * For show_trace we have tree different stack to consider:
69  *   - the panic stack which is used if the kernel stack has overflown
70  *   - the asynchronous interrupt stack (cpu related)
71  *   - the synchronous kernel stack (process related)
72  * The stack trace can start at any of the three stack and can potentially
73  * touch all of them. The order is: panic stack, async stack, sync stack.
74  */
75 static unsigned long
76 __show_trace(unsigned long sp, unsigned long low, unsigned long high)
77 {
78         struct stack_frame *sf;
79         struct pt_regs *regs;
80
81         while (1) {
82                 sp = sp & PSW_ADDR_INSN;
83                 if (sp < low || sp > high - sizeof(*sf))
84                         return sp;
85                 sf = (struct stack_frame *) sp;
86                 printk("([<%016lx>] ", sf->gprs[8] & PSW_ADDR_INSN);
87                 print_symbol("%s)\n", sf->gprs[8] & PSW_ADDR_INSN);
88                 /* Follow the backchain. */
89                 while (1) {
90                         low = sp;
91                         sp = sf->back_chain & PSW_ADDR_INSN;
92                         if (!sp)
93                                 break;
94                         if (sp <= low || sp > high - sizeof(*sf))
95                                 return sp;
96                         sf = (struct stack_frame *) sp;
97                         printk(" [<%016lx>] ", sf->gprs[8] & PSW_ADDR_INSN);
98                         print_symbol("%s\n", sf->gprs[8] & PSW_ADDR_INSN);
99                 }
100                 /* Zero backchain detected, check for interrupt frame. */
101                 sp = (unsigned long) (sf + 1);
102                 if (sp <= low || sp > high - sizeof(*regs))
103                         return sp;
104                 regs = (struct pt_regs *) sp;
105                 printk(" [<%016lx>] ", regs->psw.addr & PSW_ADDR_INSN);
106                 print_symbol("%s\n", regs->psw.addr & PSW_ADDR_INSN);
107                 low = sp;
108                 sp = regs->gprs[15];
109         }
110 }
111
112 static void show_trace(struct task_struct *task, unsigned long *stack)
113 {
114         register unsigned long __r15 asm ("15");
115         unsigned long sp;
116
117         sp = (unsigned long) stack;
118         if (!sp)
119                 sp = task ? task->thread.ksp : __r15;
120         printk("Call Trace:\n");
121 #ifdef CONFIG_CHECK_STACK
122         sp = __show_trace(sp, S390_lowcore.panic_stack - 4096,
123                           S390_lowcore.panic_stack);
124 #endif
125         sp = __show_trace(sp, S390_lowcore.async_stack - ASYNC_SIZE,
126                           S390_lowcore.async_stack);
127         if (task)
128                 __show_trace(sp, (unsigned long) task_stack_page(task),
129                              (unsigned long) task_stack_page(task) + THREAD_SIZE);
130         else
131                 __show_trace(sp, S390_lowcore.thread_info,
132                              S390_lowcore.thread_info + THREAD_SIZE);
133         if (!task)
134                 task = current;
135         debug_show_held_locks(task);
136 }
137
138 void show_stack(struct task_struct *task, unsigned long *sp)
139 {
140         register unsigned long * __r15 asm ("15");
141         unsigned long *stack;
142         int i;
143
144         if (!sp)
145                 stack = task ? (unsigned long *) task->thread.ksp : __r15;
146         else
147                 stack = sp;
148
149         for (i = 0; i < kstack_depth_to_print; i++) {
150                 if (((addr_t) stack & (THREAD_SIZE-1)) == 0)
151                         break;
152                 if (i && ((i * sizeof (long) % 32) == 0))
153                         printk("\n       ");
154                 printk(LONG, *stack++);
155         }
156         printk("\n");
157         show_trace(task, sp);
158 }
159
160 static void show_last_breaking_event(struct pt_regs *regs)
161 {
162 #ifdef CONFIG_64BIT
163         printk("Last Breaking-Event-Address:\n");
164         printk(" [<%016lx>] ", regs->args[0] & PSW_ADDR_INSN);
165         print_symbol("%s\n", regs->args[0] & PSW_ADDR_INSN);
166 #endif
167 }
168
169 /*
170  * The architecture-independent dump_stack generator
171  */
172 void dump_stack(void)
173 {
174         printk("CPU: %d %s %s %.*s\n",
175                task_thread_info(current)->cpu, print_tainted(),
176                init_utsname()->release,
177                (int)strcspn(init_utsname()->version, " "),
178                init_utsname()->version);
179         printk("Process %s (pid: %d, task: %p, ksp: %p)\n",
180                current->comm, current->pid, current,
181                (void *) current->thread.ksp);
182         show_stack(NULL, NULL);
183 }
184 EXPORT_SYMBOL(dump_stack);
185
186 static inline int mask_bits(struct pt_regs *regs, unsigned long bits)
187 {
188         return (regs->psw.mask & bits) / ((~bits + 1) & bits);
189 }
190
191 void show_registers(struct pt_regs *regs)
192 {
193         char *mode;
194
195         mode = (regs->psw.mask & PSW_MASK_PSTATE) ? "User" : "Krnl";
196         printk("%s PSW : %p %p",
197                mode, (void *) regs->psw.mask,
198                (void *) regs->psw.addr);
199         print_symbol(" (%s)\n", regs->psw.addr & PSW_ADDR_INSN);
200         printk("           R:%x T:%x IO:%x EX:%x Key:%x M:%x W:%x "
201                "P:%x AS:%x CC:%x PM:%x", mask_bits(regs, PSW_MASK_PER),
202                mask_bits(regs, PSW_MASK_DAT), mask_bits(regs, PSW_MASK_IO),
203                mask_bits(regs, PSW_MASK_EXT), mask_bits(regs, PSW_MASK_KEY),
204                mask_bits(regs, PSW_MASK_MCHECK), mask_bits(regs, PSW_MASK_WAIT),
205                mask_bits(regs, PSW_MASK_PSTATE), mask_bits(regs, PSW_MASK_ASC),
206                mask_bits(regs, PSW_MASK_CC), mask_bits(regs, PSW_MASK_PM));
207 #ifdef CONFIG_64BIT
208         printk(" EA:%x", mask_bits(regs, PSW_BASE_BITS));
209 #endif
210         printk("\n%s GPRS: " FOURLONG, mode,
211                regs->gprs[0], regs->gprs[1], regs->gprs[2], regs->gprs[3]);
212         printk("           " FOURLONG,
213                regs->gprs[4], regs->gprs[5], regs->gprs[6], regs->gprs[7]);
214         printk("           " FOURLONG,
215                regs->gprs[8], regs->gprs[9], regs->gprs[10], regs->gprs[11]);
216         printk("           " FOURLONG,
217                regs->gprs[12], regs->gprs[13], regs->gprs[14], regs->gprs[15]);
218
219         show_code(regs);
220 }       
221
222 void show_regs(struct pt_regs *regs)
223 {
224         print_modules();
225         printk("CPU: %d %s %s %.*s\n",
226                task_thread_info(current)->cpu, print_tainted(),
227                init_utsname()->release,
228                (int)strcspn(init_utsname()->version, " "),
229                init_utsname()->version);
230         printk("Process %s (pid: %d, task: %p, ksp: %p)\n",
231                current->comm, current->pid, current,
232                (void *) current->thread.ksp);
233         show_registers(regs);
234         /* Show stack backtrace if pt_regs is from kernel mode */
235         if (!(regs->psw.mask & PSW_MASK_PSTATE))
236                 show_trace(NULL, (unsigned long *) regs->gprs[15]);
237         show_last_breaking_event(regs);
238 }
239
240 /* This is called from fs/proc/array.c */
241 void task_show_regs(struct seq_file *m, struct task_struct *task)
242 {
243         struct pt_regs *regs;
244
245         regs = task_pt_regs(task);
246         seq_printf(m, "task: %p, ksp: %p\n",
247                        task, (void *)task->thread.ksp);
248         seq_printf(m, "User PSW : %p %p\n",
249                        (void *) regs->psw.mask, (void *)regs->psw.addr);
250
251         seq_printf(m, "User GPRS: " FOURLONG,
252                           regs->gprs[0], regs->gprs[1],
253                           regs->gprs[2], regs->gprs[3]);
254         seq_printf(m, "           " FOURLONG,
255                           regs->gprs[4], regs->gprs[5],
256                           regs->gprs[6], regs->gprs[7]);
257         seq_printf(m, "           " FOURLONG,
258                           regs->gprs[8], regs->gprs[9],
259                           regs->gprs[10], regs->gprs[11]);
260         seq_printf(m, "           " FOURLONG,
261                           regs->gprs[12], regs->gprs[13],
262                           regs->gprs[14], regs->gprs[15]);
263         seq_printf(m, "User ACRS: %08x %08x %08x %08x\n",
264                           task->thread.acrs[0], task->thread.acrs[1],
265                           task->thread.acrs[2], task->thread.acrs[3]);
266         seq_printf(m, "           %08x %08x %08x %08x\n",
267                           task->thread.acrs[4], task->thread.acrs[5],
268                           task->thread.acrs[6], task->thread.acrs[7]);
269         seq_printf(m, "           %08x %08x %08x %08x\n",
270                           task->thread.acrs[8], task->thread.acrs[9],
271                           task->thread.acrs[10], task->thread.acrs[11]);
272         seq_printf(m, "           %08x %08x %08x %08x\n",
273                           task->thread.acrs[12], task->thread.acrs[13],
274                           task->thread.acrs[14], task->thread.acrs[15]);
275 }
276
277 static DEFINE_SPINLOCK(die_lock);
278
279 void die(const char * str, struct pt_regs * regs, long err)
280 {
281         static int die_counter;
282
283         oops_enter();
284         debug_stop_all();
285         console_verbose();
286         spin_lock_irq(&die_lock);
287         bust_spinlocks(1);
288         printk("%s: %04lx [#%d] ", str, err & 0xffff, ++die_counter);
289 #ifdef CONFIG_PREEMPT
290         printk("PREEMPT ");
291 #endif
292 #ifdef CONFIG_SMP
293         printk("SMP ");
294 #endif
295 #ifdef CONFIG_DEBUG_PAGEALLOC
296         printk("DEBUG_PAGEALLOC");
297 #endif
298         printk("\n");
299         notify_die(DIE_OOPS, str, regs, err, current->thread.trap_no, SIGSEGV);
300         show_regs(regs);
301         bust_spinlocks(0);
302         add_taint(TAINT_DIE);
303         spin_unlock_irq(&die_lock);
304         if (in_interrupt())
305                 panic("Fatal exception in interrupt");
306         if (panic_on_oops)
307                 panic("Fatal exception: panic_on_oops");
308         oops_exit();
309         do_exit(SIGSEGV);
310 }
311
312 static void inline report_user_fault(struct pt_regs *regs, long int_code,
313                                      int signr)
314 {
315         if ((task_pid_nr(current) > 1) && !show_unhandled_signals)
316                 return;
317         if (!unhandled_signal(current, signr))
318                 return;
319         if (!printk_ratelimit())
320                 return;
321         printk("User process fault: interruption code 0x%lX ", int_code);
322         print_vma_addr("in ", regs->psw.addr & PSW_ADDR_INSN);
323         printk("\n");
324         show_regs(regs);
325 }
326
327 int is_valid_bugaddr(unsigned long addr)
328 {
329         return 1;
330 }
331
332 static inline void __kprobes do_trap(long pgm_int_code, int signr, char *str,
333                                      struct pt_regs *regs, siginfo_t *info)
334 {
335         if (notify_die(DIE_TRAP, str, regs, pgm_int_code,
336                        pgm_int_code, signr) == NOTIFY_STOP)
337                 return;
338
339         if (regs->psw.mask & PSW_MASK_PSTATE) {
340                 struct task_struct *tsk = current;
341
342                 tsk->thread.trap_no = pgm_int_code & 0xffff;
343                 force_sig_info(signr, info, tsk);
344                 report_user_fault(regs, pgm_int_code, signr);
345         } else {
346                 const struct exception_table_entry *fixup;
347                 fixup = search_exception_tables(regs->psw.addr & PSW_ADDR_INSN);
348                 if (fixup)
349                         regs->psw.addr = fixup->fixup | PSW_ADDR_AMODE;
350                 else {
351                         enum bug_trap_type btt;
352
353                         btt = report_bug(regs->psw.addr & PSW_ADDR_INSN, regs);
354                         if (btt == BUG_TRAP_TYPE_WARN)
355                                 return;
356                         die(str, regs, pgm_int_code);
357                 }
358         }
359 }
360
361 static inline void __user *get_psw_address(struct pt_regs *regs,
362                                            long pgm_int_code)
363 {
364         return (void __user *)
365                 ((regs->psw.addr - (pgm_int_code >> 16)) & PSW_ADDR_INSN);
366 }
367
368 void __kprobes do_single_step(struct pt_regs *regs)
369 {
370         if (notify_die(DIE_SSTEP, "sstep", regs, 0, 0,
371                                         SIGTRAP) == NOTIFY_STOP){
372                 return;
373         }
374         if (tracehook_consider_fatal_signal(current, SIGTRAP))
375                 force_sig(SIGTRAP, current);
376 }
377
378 static void default_trap_handler(struct pt_regs *regs, long pgm_int_code,
379                                  unsigned long trans_exc_code)
380 {
381         if (regs->psw.mask & PSW_MASK_PSTATE) {
382                 report_user_fault(regs, pgm_int_code, SIGSEGV);
383                 do_exit(SIGSEGV);
384         } else
385                 die("Unknown program exception", regs, pgm_int_code);
386 }
387
388 #define DO_ERROR_INFO(name, signr, sicode, str) \
389 static void name(struct pt_regs *regs, long pgm_int_code, \
390                  unsigned long trans_exc_code) \
391 { \
392         siginfo_t info; \
393         info.si_signo = signr; \
394         info.si_errno = 0; \
395         info.si_code = sicode; \
396         info.si_addr = get_psw_address(regs, pgm_int_code); \
397         do_trap(pgm_int_code, signr, str, regs, &info);     \
398 }
399
400 DO_ERROR_INFO(addressing_exception, SIGILL, ILL_ILLADR,
401               "addressing exception")
402 DO_ERROR_INFO(execute_exception, SIGILL, ILL_ILLOPN,
403               "execute exception")
404 DO_ERROR_INFO(divide_exception, SIGFPE, FPE_INTDIV,
405               "fixpoint divide exception")
406 DO_ERROR_INFO(overflow_exception, SIGFPE, FPE_INTOVF,
407               "fixpoint overflow exception")
408 DO_ERROR_INFO(hfp_overflow_exception, SIGFPE, FPE_FLTOVF,
409               "HFP overflow exception")
410 DO_ERROR_INFO(hfp_underflow_exception, SIGFPE, FPE_FLTUND,
411               "HFP underflow exception")
412 DO_ERROR_INFO(hfp_significance_exception, SIGFPE, FPE_FLTRES,
413               "HFP significance exception")
414 DO_ERROR_INFO(hfp_divide_exception, SIGFPE, FPE_FLTDIV,
415               "HFP divide exception")
416 DO_ERROR_INFO(hfp_sqrt_exception, SIGFPE, FPE_FLTINV,
417               "HFP square root exception")
418 DO_ERROR_INFO(operand_exception, SIGILL, ILL_ILLOPN,
419               "operand exception")
420 DO_ERROR_INFO(privileged_op, SIGILL, ILL_PRVOPC,
421               "privileged operation")
422 DO_ERROR_INFO(special_op_exception, SIGILL, ILL_ILLOPN,
423               "special operation exception")
424 DO_ERROR_INFO(translation_exception, SIGILL, ILL_ILLOPN,
425               "translation exception")
426
427 static inline void do_fp_trap(struct pt_regs *regs, void __user *location,
428                               int fpc, long pgm_int_code)
429 {
430         siginfo_t si;
431
432         si.si_signo = SIGFPE;
433         si.si_errno = 0;
434         si.si_addr = location;
435         si.si_code = 0;
436         /* FPC[2] is Data Exception Code */
437         if ((fpc & 0x00000300) == 0) {
438                 /* bits 6 and 7 of DXC are 0 iff IEEE exception */
439                 if (fpc & 0x8000) /* invalid fp operation */
440                         si.si_code = FPE_FLTINV;
441                 else if (fpc & 0x4000) /* div by 0 */
442                         si.si_code = FPE_FLTDIV;
443                 else if (fpc & 0x2000) /* overflow */
444                         si.si_code = FPE_FLTOVF;
445                 else if (fpc & 0x1000) /* underflow */
446                         si.si_code = FPE_FLTUND;
447                 else if (fpc & 0x0800) /* inexact */
448                         si.si_code = FPE_FLTRES;
449         }
450         current->thread.ieee_instruction_pointer = (addr_t) location;
451         do_trap(pgm_int_code, SIGFPE,
452                 "floating point exception", regs, &si);
453 }
454
455 static void illegal_op(struct pt_regs *regs, long pgm_int_code,
456                        unsigned long trans_exc_code)
457 {
458         siginfo_t info;
459         __u8 opcode[6];
460         __u16 __user *location;
461         int signal = 0;
462
463         location = get_psw_address(regs, pgm_int_code);
464
465         if (regs->psw.mask & PSW_MASK_PSTATE) {
466                 if (get_user(*((__u16 *) opcode), (__u16 __user *) location))
467                         return;
468                 if (*((__u16 *) opcode) == S390_BREAKPOINT_U16) {
469                         if (tracehook_consider_fatal_signal(current, SIGTRAP))
470                                 force_sig(SIGTRAP, current);
471                         else
472                                 signal = SIGILL;
473 #ifdef CONFIG_MATHEMU
474                 } else if (opcode[0] == 0xb3) {
475                         if (get_user(*((__u16 *) (opcode+2)), location+1))
476                                 return;
477                         signal = math_emu_b3(opcode, regs);
478                 } else if (opcode[0] == 0xed) {
479                         if (get_user(*((__u32 *) (opcode+2)),
480                                      (__u32 __user *)(location+1)))
481                                 return;
482                         signal = math_emu_ed(opcode, regs);
483                 } else if (*((__u16 *) opcode) == 0xb299) {
484                         if (get_user(*((__u16 *) (opcode+2)), location+1))
485                                 return;
486                         signal = math_emu_srnm(opcode, regs);
487                 } else if (*((__u16 *) opcode) == 0xb29c) {
488                         if (get_user(*((__u16 *) (opcode+2)), location+1))
489                                 return;
490                         signal = math_emu_stfpc(opcode, regs);
491                 } else if (*((__u16 *) opcode) == 0xb29d) {
492                         if (get_user(*((__u16 *) (opcode+2)), location+1))
493                                 return;
494                         signal = math_emu_lfpc(opcode, regs);
495 #endif
496                 } else
497                         signal = SIGILL;
498         } else {
499                 /*
500                  * If we get an illegal op in kernel mode, send it through the
501                  * kprobes notifier. If kprobes doesn't pick it up, SIGILL
502                  */
503                 if (notify_die(DIE_BPT, "bpt", regs, pgm_int_code,
504                                3, SIGTRAP) != NOTIFY_STOP)
505                         signal = SIGILL;
506         }
507
508 #ifdef CONFIG_MATHEMU
509         if (signal == SIGFPE)
510                 do_fp_trap(regs, location,
511                            current->thread.fp_regs.fpc, pgm_int_code);
512         else if (signal == SIGSEGV) {
513                 info.si_signo = signal;
514                 info.si_errno = 0;
515                 info.si_code = SEGV_MAPERR;
516                 info.si_addr = (void __user *) location;
517                 do_trap(pgm_int_code, signal,
518                         "user address fault", regs, &info);
519         } else
520 #endif
521         if (signal) {
522                 info.si_signo = signal;
523                 info.si_errno = 0;
524                 info.si_code = ILL_ILLOPC;
525                 info.si_addr = (void __user *) location;
526                 do_trap(pgm_int_code, signal,
527                         "illegal operation", regs, &info);
528         }
529 }
530
531
532 #ifdef CONFIG_MATHEMU
533 asmlinkage void specification_exception(struct pt_regs *regs,
534                                         long pgm_int_code,
535                                         unsigned long trans_exc_code)
536 {
537         __u8 opcode[6];
538         __u16 __user *location = NULL;
539         int signal = 0;
540
541         location = (__u16 __user *) get_psw_address(regs, pgm_int_code);
542
543         if (regs->psw.mask & PSW_MASK_PSTATE) {
544                 get_user(*((__u16 *) opcode), location);
545                 switch (opcode[0]) {
546                 case 0x28: /* LDR Rx,Ry   */
547                         signal = math_emu_ldr(opcode);
548                         break;
549                 case 0x38: /* LER Rx,Ry   */
550                         signal = math_emu_ler(opcode);
551                         break;
552                 case 0x60: /* STD R,D(X,B) */
553                         get_user(*((__u16 *) (opcode+2)), location+1);
554                         signal = math_emu_std(opcode, regs);
555                         break;
556                 case 0x68: /* LD R,D(X,B) */
557                         get_user(*((__u16 *) (opcode+2)), location+1);
558                         signal = math_emu_ld(opcode, regs);
559                         break;
560                 case 0x70: /* STE R,D(X,B) */
561                         get_user(*((__u16 *) (opcode+2)), location+1);
562                         signal = math_emu_ste(opcode, regs);
563                         break;
564                 case 0x78: /* LE R,D(X,B) */
565                         get_user(*((__u16 *) (opcode+2)), location+1);
566                         signal = math_emu_le(opcode, regs);
567                         break;
568                 default:
569                         signal = SIGILL;
570                         break;
571                 }
572         } else
573                 signal = SIGILL;
574
575         if (signal == SIGFPE)
576                 do_fp_trap(regs, location,
577                            current->thread.fp_regs.fpc, pgm_int_code);
578         else if (signal) {
579                 siginfo_t info;
580                 info.si_signo = signal;
581                 info.si_errno = 0;
582                 info.si_code = ILL_ILLOPN;
583                 info.si_addr = location;
584                 do_trap(pgm_int_code, signal,
585                         "specification exception", regs, &info);
586         }
587 }
588 #else
589 DO_ERROR_INFO(specification_exception, SIGILL, ILL_ILLOPN,
590               "specification exception");
591 #endif
592
593 static void data_exception(struct pt_regs *regs, long pgm_int_code,
594                            unsigned long trans_exc_code)
595 {
596         __u16 __user *location;
597         int signal = 0;
598
599         location = get_psw_address(regs, pgm_int_code);
600
601         if (MACHINE_HAS_IEEE)
602                 asm volatile("stfpc %0" : "=m" (current->thread.fp_regs.fpc));
603
604 #ifdef CONFIG_MATHEMU
605         else if (regs->psw.mask & PSW_MASK_PSTATE) {
606                 __u8 opcode[6];
607                 get_user(*((__u16 *) opcode), location);
608                 switch (opcode[0]) {
609                 case 0x28: /* LDR Rx,Ry   */
610                         signal = math_emu_ldr(opcode);
611                         break;
612                 case 0x38: /* LER Rx,Ry   */
613                         signal = math_emu_ler(opcode);
614                         break;
615                 case 0x60: /* STD R,D(X,B) */
616                         get_user(*((__u16 *) (opcode+2)), location+1);
617                         signal = math_emu_std(opcode, regs);
618                         break;
619                 case 0x68: /* LD R,D(X,B) */
620                         get_user(*((__u16 *) (opcode+2)), location+1);
621                         signal = math_emu_ld(opcode, regs);
622                         break;
623                 case 0x70: /* STE R,D(X,B) */
624                         get_user(*((__u16 *) (opcode+2)), location+1);
625                         signal = math_emu_ste(opcode, regs);
626                         break;
627                 case 0x78: /* LE R,D(X,B) */
628                         get_user(*((__u16 *) (opcode+2)), location+1);
629                         signal = math_emu_le(opcode, regs);
630                         break;
631                 case 0xb3:
632                         get_user(*((__u16 *) (opcode+2)), location+1);
633                         signal = math_emu_b3(opcode, regs);
634                         break;
635                 case 0xed:
636                         get_user(*((__u32 *) (opcode+2)),
637                                  (__u32 __user *)(location+1));
638                         signal = math_emu_ed(opcode, regs);
639                         break;
640                 case 0xb2:
641                         if (opcode[1] == 0x99) {
642                                 get_user(*((__u16 *) (opcode+2)), location+1);
643                                 signal = math_emu_srnm(opcode, regs);
644                         } else if (opcode[1] == 0x9c) {
645                                 get_user(*((__u16 *) (opcode+2)), location+1);
646                                 signal = math_emu_stfpc(opcode, regs);
647                         } else if (opcode[1] == 0x9d) {
648                                 get_user(*((__u16 *) (opcode+2)), location+1);
649                                 signal = math_emu_lfpc(opcode, regs);
650                         } else
651                                 signal = SIGILL;
652                         break;
653                 default:
654                         signal = SIGILL;
655                         break;
656                 }
657         }
658 #endif 
659         if (current->thread.fp_regs.fpc & FPC_DXC_MASK)
660                 signal = SIGFPE;
661         else
662                 signal = SIGILL;
663         if (signal == SIGFPE)
664                 do_fp_trap(regs, location,
665                            current->thread.fp_regs.fpc, pgm_int_code);
666         else if (signal) {
667                 siginfo_t info;
668                 info.si_signo = signal;
669                 info.si_errno = 0;
670                 info.si_code = ILL_ILLOPN;
671                 info.si_addr = location;
672                 do_trap(pgm_int_code, signal, "data exception", regs, &info);
673         }
674 }
675
676 static void space_switch_exception(struct pt_regs *regs, long pgm_int_code,
677                                    unsigned long trans_exc_code)
678 {
679         siginfo_t info;
680
681         /* Set user psw back to home space mode. */
682         if (regs->psw.mask & PSW_MASK_PSTATE)
683                 regs->psw.mask |= PSW_ASC_HOME;
684         /* Send SIGILL. */
685         info.si_signo = SIGILL;
686         info.si_errno = 0;
687         info.si_code = ILL_PRVOPC;
688         info.si_addr = get_psw_address(regs, pgm_int_code);
689         do_trap(pgm_int_code, SIGILL, "space switch event", regs, &info);
690 }
691
692 asmlinkage void kernel_stack_overflow(struct pt_regs * regs)
693 {
694         bust_spinlocks(1);
695         printk("Kernel stack overflow.\n");
696         show_regs(regs);
697         bust_spinlocks(0);
698         panic("Corrupt kernel stack, can't continue.");
699 }
700
701 /* init is done in lowcore.S and head.S */
702
703 void __init trap_init(void)
704 {
705         int i;
706
707         for (i = 0; i < 128; i++)
708           pgm_check_table[i] = &default_trap_handler;
709         pgm_check_table[1] = &illegal_op;
710         pgm_check_table[2] = &privileged_op;
711         pgm_check_table[3] = &execute_exception;
712         pgm_check_table[4] = &do_protection_exception;
713         pgm_check_table[5] = &addressing_exception;
714         pgm_check_table[6] = &specification_exception;
715         pgm_check_table[7] = &data_exception;
716         pgm_check_table[8] = &overflow_exception;
717         pgm_check_table[9] = &divide_exception;
718         pgm_check_table[0x0A] = &overflow_exception;
719         pgm_check_table[0x0B] = &divide_exception;
720         pgm_check_table[0x0C] = &hfp_overflow_exception;
721         pgm_check_table[0x0D] = &hfp_underflow_exception;
722         pgm_check_table[0x0E] = &hfp_significance_exception;
723         pgm_check_table[0x0F] = &hfp_divide_exception;
724         pgm_check_table[0x10] = &do_dat_exception;
725         pgm_check_table[0x11] = &do_dat_exception;
726         pgm_check_table[0x12] = &translation_exception;
727         pgm_check_table[0x13] = &special_op_exception;
728 #ifdef CONFIG_64BIT
729         pgm_check_table[0x38] = &do_asce_exception;
730         pgm_check_table[0x39] = &do_dat_exception;
731         pgm_check_table[0x3A] = &do_dat_exception;
732         pgm_check_table[0x3B] = &do_dat_exception;
733 #endif /* CONFIG_64BIT */
734         pgm_check_table[0x15] = &operand_exception;
735         pgm_check_table[0x1C] = &space_switch_exception;
736         pgm_check_table[0x1D] = &hfp_sqrt_exception;
737         pfault_irq_init();
738 }