Root/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
47pgm_check_handler_t *pgm_check_table[128];
48
49int show_unhandled_signals;
50
51extern pgm_check_handler_t do_protection_exception;
52extern pgm_check_handler_t do_dat_exception;
53extern 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"
60static int kstack_depth_to_print = 12;
61#else /* CONFIG_64BIT */
62#define LONG "%016lx "
63#define FOURLONG "%016lx %016lx %016lx %016lx\n"
64static 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 */
75static 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
112static 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
138void 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
160static 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 */
172void 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}
184EXPORT_SYMBOL(dump_stack);
185
186static inline int mask_bits(struct pt_regs *regs, unsigned long bits)
187{
188    return (regs->psw.mask & bits) / ((~bits + 1) & bits);
189}
190
191void 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
222void 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 */
241void 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
277static DEFINE_SPINLOCK(die_lock);
278
279void 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
312static 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
327int is_valid_bugaddr(unsigned long addr)
328{
329    return 1;
330}
331
332static 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
361static 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
368void __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
378static 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) \
389static 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
400DO_ERROR_INFO(addressing_exception, SIGILL, ILL_ILLADR,
401          "addressing exception")
402DO_ERROR_INFO(execute_exception, SIGILL, ILL_ILLOPN,
403          "execute exception")
404DO_ERROR_INFO(divide_exception, SIGFPE, FPE_INTDIV,
405          "fixpoint divide exception")
406DO_ERROR_INFO(overflow_exception, SIGFPE, FPE_INTOVF,
407          "fixpoint overflow exception")
408DO_ERROR_INFO(hfp_overflow_exception, SIGFPE, FPE_FLTOVF,
409          "HFP overflow exception")
410DO_ERROR_INFO(hfp_underflow_exception, SIGFPE, FPE_FLTUND,
411          "HFP underflow exception")
412DO_ERROR_INFO(hfp_significance_exception, SIGFPE, FPE_FLTRES,
413          "HFP significance exception")
414DO_ERROR_INFO(hfp_divide_exception, SIGFPE, FPE_FLTDIV,
415          "HFP divide exception")
416DO_ERROR_INFO(hfp_sqrt_exception, SIGFPE, FPE_FLTINV,
417          "HFP square root exception")
418DO_ERROR_INFO(operand_exception, SIGILL, ILL_ILLOPN,
419          "operand exception")
420DO_ERROR_INFO(privileged_op, SIGILL, ILL_PRVOPC,
421          "privileged operation")
422DO_ERROR_INFO(special_op_exception, SIGILL, ILL_ILLOPN,
423          "special operation exception")
424DO_ERROR_INFO(translation_exception, SIGILL, ILL_ILLOPN,
425          "translation exception")
426
427static 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    do_trap(pgm_int_code, SIGFPE,
451        "floating point exception", regs, &si);
452}
453
454static void illegal_op(struct pt_regs *regs, long pgm_int_code,
455               unsigned long trans_exc_code)
456{
457    siginfo_t info;
458        __u8 opcode[6];
459    __u16 __user *location;
460    int signal = 0;
461
462    location = get_psw_address(regs, pgm_int_code);
463
464    if (regs->psw.mask & PSW_MASK_PSTATE) {
465        if (get_user(*((__u16 *) opcode), (__u16 __user *) location))
466            return;
467        if (*((__u16 *) opcode) == S390_BREAKPOINT_U16) {
468            if (tracehook_consider_fatal_signal(current, SIGTRAP))
469                force_sig(SIGTRAP, current);
470            else
471                signal = SIGILL;
472#ifdef CONFIG_MATHEMU
473        } else if (opcode[0] == 0xb3) {
474            if (get_user(*((__u16 *) (opcode+2)), location+1))
475                return;
476            signal = math_emu_b3(opcode, regs);
477                } else if (opcode[0] == 0xed) {
478            if (get_user(*((__u32 *) (opcode+2)),
479                     (__u32 __user *)(location+1)))
480                return;
481            signal = math_emu_ed(opcode, regs);
482        } else if (*((__u16 *) opcode) == 0xb299) {
483            if (get_user(*((__u16 *) (opcode+2)), location+1))
484                return;
485            signal = math_emu_srnm(opcode, regs);
486        } else if (*((__u16 *) opcode) == 0xb29c) {
487            if (get_user(*((__u16 *) (opcode+2)), location+1))
488                return;
489            signal = math_emu_stfpc(opcode, regs);
490        } else if (*((__u16 *) opcode) == 0xb29d) {
491            if (get_user(*((__u16 *) (opcode+2)), location+1))
492                return;
493            signal = math_emu_lfpc(opcode, regs);
494#endif
495        } else
496            signal = SIGILL;
497    } else {
498        /*
499         * If we get an illegal op in kernel mode, send it through the
500         * kprobes notifier. If kprobes doesn't pick it up, SIGILL
501         */
502        if (notify_die(DIE_BPT, "bpt", regs, pgm_int_code,
503                   3, SIGTRAP) != NOTIFY_STOP)
504            signal = SIGILL;
505    }
506
507#ifdef CONFIG_MATHEMU
508        if (signal == SIGFPE)
509        do_fp_trap(regs, location,
510               current->thread.fp_regs.fpc, pgm_int_code);
511        else if (signal == SIGSEGV) {
512        info.si_signo = signal;
513        info.si_errno = 0;
514        info.si_code = SEGV_MAPERR;
515        info.si_addr = (void __user *) location;
516        do_trap(pgm_int_code, signal,
517            "user address fault", regs, &info);
518    } else
519#endif
520        if (signal) {
521        info.si_signo = signal;
522        info.si_errno = 0;
523        info.si_code = ILL_ILLOPC;
524        info.si_addr = (void __user *) location;
525        do_trap(pgm_int_code, signal,
526            "illegal operation", regs, &info);
527    }
528}
529
530
531#ifdef CONFIG_MATHEMU
532asmlinkage void specification_exception(struct pt_regs *regs,
533                    long pgm_int_code,
534                    unsigned long trans_exc_code)
535{
536        __u8 opcode[6];
537    __u16 __user *location = NULL;
538    int signal = 0;
539
540    location = (__u16 __user *) get_psw_address(regs, pgm_int_code);
541
542        if (regs->psw.mask & PSW_MASK_PSTATE) {
543        get_user(*((__u16 *) opcode), location);
544        switch (opcode[0]) {
545        case 0x28: /* LDR Rx,Ry */
546            signal = math_emu_ldr(opcode);
547            break;
548        case 0x38: /* LER Rx,Ry */
549            signal = math_emu_ler(opcode);
550            break;
551        case 0x60: /* STD R,D(X,B) */
552            get_user(*((__u16 *) (opcode+2)), location+1);
553            signal = math_emu_std(opcode, regs);
554            break;
555        case 0x68: /* LD R,D(X,B) */
556            get_user(*((__u16 *) (opcode+2)), location+1);
557            signal = math_emu_ld(opcode, regs);
558            break;
559        case 0x70: /* STE R,D(X,B) */
560            get_user(*((__u16 *) (opcode+2)), location+1);
561            signal = math_emu_ste(opcode, regs);
562            break;
563        case 0x78: /* LE R,D(X,B) */
564            get_user(*((__u16 *) (opcode+2)), location+1);
565            signal = math_emu_le(opcode, regs);
566            break;
567        default:
568            signal = SIGILL;
569            break;
570                }
571        } else
572        signal = SIGILL;
573
574        if (signal == SIGFPE)
575        do_fp_trap(regs, location,
576               current->thread.fp_regs.fpc, pgm_int_code);
577        else if (signal) {
578        siginfo_t info;
579        info.si_signo = signal;
580        info.si_errno = 0;
581        info.si_code = ILL_ILLOPN;
582        info.si_addr = location;
583        do_trap(pgm_int_code, signal,
584            "specification exception", regs, &info);
585    }
586}
587#else
588DO_ERROR_INFO(specification_exception, SIGILL, ILL_ILLOPN,
589          "specification exception");
590#endif
591
592static void data_exception(struct pt_regs *regs, long pgm_int_code,
593               unsigned long trans_exc_code)
594{
595    __u16 __user *location;
596    int signal = 0;
597
598    location = get_psw_address(regs, pgm_int_code);
599
600    if (MACHINE_HAS_IEEE)
601        asm volatile("stfpc %0" : "=m" (current->thread.fp_regs.fpc));
602
603#ifdef CONFIG_MATHEMU
604        else if (regs->psw.mask & PSW_MASK_PSTATE) {
605            __u8 opcode[6];
606        get_user(*((__u16 *) opcode), location);
607        switch (opcode[0]) {
608        case 0x28: /* LDR Rx,Ry */
609            signal = math_emu_ldr(opcode);
610            break;
611        case 0x38: /* LER Rx,Ry */
612            signal = math_emu_ler(opcode);
613            break;
614        case 0x60: /* STD R,D(X,B) */
615            get_user(*((__u16 *) (opcode+2)), location+1);
616            signal = math_emu_std(opcode, regs);
617            break;
618        case 0x68: /* LD R,D(X,B) */
619            get_user(*((__u16 *) (opcode+2)), location+1);
620            signal = math_emu_ld(opcode, regs);
621            break;
622        case 0x70: /* STE R,D(X,B) */
623            get_user(*((__u16 *) (opcode+2)), location+1);
624            signal = math_emu_ste(opcode, regs);
625            break;
626        case 0x78: /* LE R,D(X,B) */
627            get_user(*((__u16 *) (opcode+2)), location+1);
628            signal = math_emu_le(opcode, regs);
629            break;
630        case 0xb3:
631            get_user(*((__u16 *) (opcode+2)), location+1);
632            signal = math_emu_b3(opcode, regs);
633            break;
634                case 0xed:
635            get_user(*((__u32 *) (opcode+2)),
636                 (__u32 __user *)(location+1));
637            signal = math_emu_ed(opcode, regs);
638            break;
639            case 0xb2:
640            if (opcode[1] == 0x99) {
641                get_user(*((__u16 *) (opcode+2)), location+1);
642                signal = math_emu_srnm(opcode, regs);
643            } else if (opcode[1] == 0x9c) {
644                get_user(*((__u16 *) (opcode+2)), location+1);
645                signal = math_emu_stfpc(opcode, regs);
646            } else if (opcode[1] == 0x9d) {
647                get_user(*((__u16 *) (opcode+2)), location+1);
648                signal = math_emu_lfpc(opcode, regs);
649            } else
650                signal = SIGILL;
651            break;
652        default:
653            signal = SIGILL;
654            break;
655                }
656        }
657#endif
658    if (current->thread.fp_regs.fpc & FPC_DXC_MASK)
659        signal = SIGFPE;
660    else
661        signal = SIGILL;
662        if (signal == SIGFPE)
663        do_fp_trap(regs, location,
664               current->thread.fp_regs.fpc, pgm_int_code);
665        else if (signal) {
666        siginfo_t info;
667        info.si_signo = signal;
668        info.si_errno = 0;
669        info.si_code = ILL_ILLOPN;
670        info.si_addr = location;
671        do_trap(pgm_int_code, signal, "data exception", regs, &info);
672    }
673}
674
675static void space_switch_exception(struct pt_regs *regs, long pgm_int_code,
676                   unsigned long trans_exc_code)
677{
678        siginfo_t info;
679
680    /* Set user psw back to home space mode. */
681    if (regs->psw.mask & PSW_MASK_PSTATE)
682        regs->psw.mask |= PSW_ASC_HOME;
683    /* Send SIGILL. */
684        info.si_signo = SIGILL;
685        info.si_errno = 0;
686        info.si_code = ILL_PRVOPC;
687    info.si_addr = get_psw_address(regs, pgm_int_code);
688    do_trap(pgm_int_code, SIGILL, "space switch event", regs, &info);
689}
690
691asmlinkage void kernel_stack_overflow(struct pt_regs * regs)
692{
693    bust_spinlocks(1);
694    printk("Kernel stack overflow.\n");
695    show_regs(regs);
696    bust_spinlocks(0);
697    panic("Corrupt kernel stack, can't continue.");
698}
699
700/* init is done in lowcore.S and head.S */
701
702void __init trap_init(void)
703{
704        int i;
705
706        for (i = 0; i < 128; i++)
707          pgm_check_table[i] = &default_trap_handler;
708        pgm_check_table[1] = &illegal_op;
709        pgm_check_table[2] = &privileged_op;
710        pgm_check_table[3] = &execute_exception;
711        pgm_check_table[4] = &do_protection_exception;
712        pgm_check_table[5] = &addressing_exception;
713        pgm_check_table[6] = &specification_exception;
714        pgm_check_table[7] = &data_exception;
715        pgm_check_table[8] = &overflow_exception;
716        pgm_check_table[9] = &divide_exception;
717        pgm_check_table[0x0A] = &overflow_exception;
718        pgm_check_table[0x0B] = &divide_exception;
719        pgm_check_table[0x0C] = &hfp_overflow_exception;
720        pgm_check_table[0x0D] = &hfp_underflow_exception;
721        pgm_check_table[0x0E] = &hfp_significance_exception;
722        pgm_check_table[0x0F] = &hfp_divide_exception;
723        pgm_check_table[0x10] = &do_dat_exception;
724        pgm_check_table[0x11] = &do_dat_exception;
725        pgm_check_table[0x12] = &translation_exception;
726        pgm_check_table[0x13] = &special_op_exception;
727#ifdef CONFIG_64BIT
728    pgm_check_table[0x38] = &do_asce_exception;
729    pgm_check_table[0x39] = &do_dat_exception;
730    pgm_check_table[0x3A] = &do_dat_exception;
731        pgm_check_table[0x3B] = &do_dat_exception;
732#endif /* CONFIG_64BIT */
733        pgm_check_table[0x15] = &operand_exception;
734        pgm_check_table[0x1C] = &space_switch_exception;
735        pgm_check_table[0x1D] = &hfp_sqrt_exception;
736    pfault_irq_init();
737}
738

Archive Download this file



interactive