forked from luck/tmp_suning_uos_patched
659 lines
15 KiB
C
659 lines
15 KiB
C
/* traps.c: high-level exception handler for FR-V
|
|
*
|
|
* Copyright (C) 2003 Red Hat, Inc. All Rights Reserved.
|
|
* Written by David Howells (dhowells@redhat.com)
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version
|
|
* 2 of the License, or (at your option) any later version.
|
|
*/
|
|
|
|
#include <linux/sched.h>
|
|
#include <linux/signal.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/types.h>
|
|
#include <linux/user.h>
|
|
#include <linux/string.h>
|
|
#include <linux/linkage.h>
|
|
#include <linux/init.h>
|
|
#include <linux/module.h>
|
|
|
|
#include <asm/asm-offsets.h>
|
|
#include <asm/setup.h>
|
|
#include <asm/fpu.h>
|
|
#include <asm/uaccess.h>
|
|
#include <asm/pgtable.h>
|
|
#include <asm/siginfo.h>
|
|
#include <asm/unaligned.h>
|
|
|
|
void show_backtrace(struct pt_regs *, unsigned long);
|
|
|
|
extern asmlinkage void __break_hijack_kernel_event(void);
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* instruction access error
|
|
*/
|
|
asmlinkage void insn_access_error(unsigned long esfr1, unsigned long epcr0, unsigned long esr0)
|
|
{
|
|
siginfo_t info;
|
|
|
|
die_if_kernel("-- Insn Access Error --\n"
|
|
"EPCR0 : %08lx\n"
|
|
"ESR0 : %08lx\n",
|
|
epcr0, esr0);
|
|
|
|
info.si_signo = SIGSEGV;
|
|
info.si_code = SEGV_ACCERR;
|
|
info.si_errno = 0;
|
|
info.si_addr = (void __user *) ((epcr0 & EPCR0_V) ? (epcr0 & EPCR0_PC) : __frame->pc);
|
|
|
|
force_sig_info(info.si_signo, &info, current);
|
|
} /* end insn_access_error() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* handler for:
|
|
* - illegal instruction
|
|
* - privileged instruction
|
|
* - unsupported trap
|
|
* - debug exceptions
|
|
*/
|
|
asmlinkage void illegal_instruction(unsigned long esfr1, unsigned long epcr0, unsigned long esr0)
|
|
{
|
|
siginfo_t info;
|
|
|
|
die_if_kernel("-- Illegal Instruction --\n"
|
|
"EPCR0 : %08lx\n"
|
|
"ESR0 : %08lx\n"
|
|
"ESFR1 : %08lx\n",
|
|
epcr0, esr0, esfr1);
|
|
|
|
info.si_errno = 0;
|
|
info.si_addr = (void __user *) ((epcr0 & EPCR0_V) ? (epcr0 & EPCR0_PC) : __frame->pc);
|
|
|
|
switch (__frame->tbr & TBR_TT) {
|
|
case TBR_TT_ILLEGAL_INSTR:
|
|
info.si_signo = SIGILL;
|
|
info.si_code = ILL_ILLOPC;
|
|
break;
|
|
case TBR_TT_PRIV_INSTR:
|
|
info.si_signo = SIGILL;
|
|
info.si_code = ILL_PRVOPC;
|
|
break;
|
|
case TBR_TT_TRAP2 ... TBR_TT_TRAP126:
|
|
info.si_signo = SIGILL;
|
|
info.si_code = ILL_ILLTRP;
|
|
break;
|
|
/* GDB uses "tira gr0, #1" as a breakpoint instruction. */
|
|
case TBR_TT_TRAP1:
|
|
case TBR_TT_BREAK:
|
|
info.si_signo = SIGTRAP;
|
|
info.si_code =
|
|
(__frame->__status & REG__STATUS_STEPPED) ? TRAP_TRACE : TRAP_BRKPT;
|
|
break;
|
|
}
|
|
|
|
force_sig_info(info.si_signo, &info, current);
|
|
} /* end illegal_instruction() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* handle atomic operations with errors
|
|
* - arguments in gr8, gr9, gr10
|
|
* - original memory value placed in gr5
|
|
* - replacement memory value placed in gr9
|
|
*/
|
|
asmlinkage void atomic_operation(unsigned long esfr1, unsigned long epcr0,
|
|
unsigned long esr0)
|
|
{
|
|
static DEFINE_SPINLOCK(atomic_op_lock);
|
|
unsigned long x, y, z;
|
|
unsigned long __user *p;
|
|
mm_segment_t oldfs;
|
|
siginfo_t info;
|
|
int ret;
|
|
|
|
y = 0;
|
|
z = 0;
|
|
|
|
oldfs = get_fs();
|
|
if (!user_mode(__frame))
|
|
set_fs(KERNEL_DS);
|
|
|
|
switch (__frame->tbr & TBR_TT) {
|
|
/* TIRA gr0,#120
|
|
* u32 __atomic_user_cmpxchg32(u32 *ptr, u32 test, u32 new)
|
|
*/
|
|
case TBR_TT_ATOMIC_CMPXCHG32:
|
|
p = (unsigned long __user *) __frame->gr8;
|
|
x = __frame->gr9;
|
|
y = __frame->gr10;
|
|
|
|
for (;;) {
|
|
ret = get_user(z, p);
|
|
if (ret < 0)
|
|
goto error;
|
|
|
|
if (z != x)
|
|
goto done;
|
|
|
|
spin_lock_irq(&atomic_op_lock);
|
|
|
|
if (__get_user(z, p) == 0) {
|
|
if (z != x)
|
|
goto done2;
|
|
|
|
if (__put_user(y, p) == 0)
|
|
goto done2;
|
|
goto error2;
|
|
}
|
|
|
|
spin_unlock_irq(&atomic_op_lock);
|
|
}
|
|
|
|
/* TIRA gr0,#121
|
|
* u32 __atomic_kernel_xchg32(void *v, u32 new)
|
|
*/
|
|
case TBR_TT_ATOMIC_XCHG32:
|
|
p = (unsigned long __user *) __frame->gr8;
|
|
y = __frame->gr9;
|
|
|
|
for (;;) {
|
|
ret = get_user(z, p);
|
|
if (ret < 0)
|
|
goto error;
|
|
|
|
spin_lock_irq(&atomic_op_lock);
|
|
|
|
if (__get_user(z, p) == 0) {
|
|
if (__put_user(y, p) == 0)
|
|
goto done2;
|
|
goto error2;
|
|
}
|
|
|
|
spin_unlock_irq(&atomic_op_lock);
|
|
}
|
|
|
|
/* TIRA gr0,#122
|
|
* ulong __atomic_kernel_XOR_return(ulong i, ulong *v)
|
|
*/
|
|
case TBR_TT_ATOMIC_XOR:
|
|
p = (unsigned long __user *) __frame->gr8;
|
|
x = __frame->gr9;
|
|
|
|
for (;;) {
|
|
ret = get_user(z, p);
|
|
if (ret < 0)
|
|
goto error;
|
|
|
|
spin_lock_irq(&atomic_op_lock);
|
|
|
|
if (__get_user(z, p) == 0) {
|
|
y = x ^ z;
|
|
if (__put_user(y, p) == 0)
|
|
goto done2;
|
|
goto error2;
|
|
}
|
|
|
|
spin_unlock_irq(&atomic_op_lock);
|
|
}
|
|
|
|
/* TIRA gr0,#123
|
|
* ulong __atomic_kernel_OR_return(ulong i, ulong *v)
|
|
*/
|
|
case TBR_TT_ATOMIC_OR:
|
|
p = (unsigned long __user *) __frame->gr8;
|
|
x = __frame->gr9;
|
|
|
|
for (;;) {
|
|
ret = get_user(z, p);
|
|
if (ret < 0)
|
|
goto error;
|
|
|
|
spin_lock_irq(&atomic_op_lock);
|
|
|
|
if (__get_user(z, p) == 0) {
|
|
y = x ^ z;
|
|
if (__put_user(y, p) == 0)
|
|
goto done2;
|
|
goto error2;
|
|
}
|
|
|
|
spin_unlock_irq(&atomic_op_lock);
|
|
}
|
|
|
|
/* TIRA gr0,#124
|
|
* ulong __atomic_kernel_AND_return(ulong i, ulong *v)
|
|
*/
|
|
case TBR_TT_ATOMIC_AND:
|
|
p = (unsigned long __user *) __frame->gr8;
|
|
x = __frame->gr9;
|
|
|
|
for (;;) {
|
|
ret = get_user(z, p);
|
|
if (ret < 0)
|
|
goto error;
|
|
|
|
spin_lock_irq(&atomic_op_lock);
|
|
|
|
if (__get_user(z, p) == 0) {
|
|
y = x & z;
|
|
if (__put_user(y, p) == 0)
|
|
goto done2;
|
|
goto error2;
|
|
}
|
|
|
|
spin_unlock_irq(&atomic_op_lock);
|
|
}
|
|
|
|
/* TIRA gr0,#125
|
|
* int __atomic_user_sub_return(atomic_t *v, int i)
|
|
*/
|
|
case TBR_TT_ATOMIC_SUB:
|
|
p = (unsigned long __user *) __frame->gr8;
|
|
x = __frame->gr9;
|
|
|
|
for (;;) {
|
|
ret = get_user(z, p);
|
|
if (ret < 0)
|
|
goto error;
|
|
|
|
spin_lock_irq(&atomic_op_lock);
|
|
|
|
if (__get_user(z, p) == 0) {
|
|
y = z - x;
|
|
if (__put_user(y, p) == 0)
|
|
goto done2;
|
|
goto error2;
|
|
}
|
|
|
|
spin_unlock_irq(&atomic_op_lock);
|
|
}
|
|
|
|
/* TIRA gr0,#126
|
|
* int __atomic_user_add_return(atomic_t *v, int i)
|
|
*/
|
|
case TBR_TT_ATOMIC_ADD:
|
|
p = (unsigned long __user *) __frame->gr8;
|
|
x = __frame->gr9;
|
|
|
|
for (;;) {
|
|
ret = get_user(z, p);
|
|
if (ret < 0)
|
|
goto error;
|
|
|
|
spin_lock_irq(&atomic_op_lock);
|
|
|
|
if (__get_user(z, p) == 0) {
|
|
y = z + x;
|
|
if (__put_user(y, p) == 0)
|
|
goto done2;
|
|
goto error2;
|
|
}
|
|
|
|
spin_unlock_irq(&atomic_op_lock);
|
|
}
|
|
|
|
default:
|
|
BUG();
|
|
}
|
|
|
|
done2:
|
|
spin_unlock_irq(&atomic_op_lock);
|
|
done:
|
|
if (!user_mode(__frame))
|
|
set_fs(oldfs);
|
|
__frame->gr5 = z;
|
|
__frame->gr9 = y;
|
|
return;
|
|
|
|
error2:
|
|
spin_unlock_irq(&atomic_op_lock);
|
|
error:
|
|
if (!user_mode(__frame))
|
|
set_fs(oldfs);
|
|
__frame->pc -= 4;
|
|
|
|
die_if_kernel("-- Atomic Op Error --\n");
|
|
|
|
info.si_signo = SIGSEGV;
|
|
info.si_code = SEGV_ACCERR;
|
|
info.si_errno = 0;
|
|
info.si_addr = (void __user *) __frame->pc;
|
|
|
|
force_sig_info(info.si_signo, &info, current);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
*
|
|
*/
|
|
asmlinkage void media_exception(unsigned long msr0, unsigned long msr1)
|
|
{
|
|
siginfo_t info;
|
|
|
|
die_if_kernel("-- Media Exception --\n"
|
|
"MSR0 : %08lx\n"
|
|
"MSR1 : %08lx\n",
|
|
msr0, msr1);
|
|
|
|
info.si_signo = SIGFPE;
|
|
info.si_code = FPE_MDAOVF;
|
|
info.si_errno = 0;
|
|
info.si_addr = (void __user *) __frame->pc;
|
|
|
|
force_sig_info(info.si_signo, &info, current);
|
|
} /* end media_exception() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* instruction or data access exception
|
|
*/
|
|
asmlinkage void memory_access_exception(unsigned long esr0,
|
|
unsigned long ear0,
|
|
unsigned long epcr0)
|
|
{
|
|
siginfo_t info;
|
|
|
|
#ifdef CONFIG_MMU
|
|
unsigned long fixup;
|
|
|
|
fixup = search_exception_table(__frame->pc);
|
|
if (fixup) {
|
|
__frame->pc = fixup;
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
die_if_kernel("-- Memory Access Exception --\n"
|
|
"ESR0 : %08lx\n"
|
|
"EAR0 : %08lx\n"
|
|
"EPCR0 : %08lx\n",
|
|
esr0, ear0, epcr0);
|
|
|
|
info.si_signo = SIGSEGV;
|
|
info.si_code = SEGV_ACCERR;
|
|
info.si_errno = 0;
|
|
info.si_addr = NULL;
|
|
|
|
if ((esr0 & (ESRx_VALID | ESR0_EAV)) == (ESRx_VALID | ESR0_EAV))
|
|
info.si_addr = (void __user *) ear0;
|
|
|
|
force_sig_info(info.si_signo, &info, current);
|
|
|
|
} /* end memory_access_exception() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* data access error
|
|
* - double-word data load from CPU control area (0xFExxxxxx)
|
|
* - read performed on inactive or self-refreshing SDRAM
|
|
* - error notification from slave device
|
|
* - misaligned address
|
|
* - access to out of bounds memory region
|
|
* - user mode accessing privileged memory region
|
|
* - write to R/O memory region
|
|
*/
|
|
asmlinkage void data_access_error(unsigned long esfr1, unsigned long esr15, unsigned long ear15)
|
|
{
|
|
siginfo_t info;
|
|
|
|
die_if_kernel("-- Data Access Error --\n"
|
|
"ESR15 : %08lx\n"
|
|
"EAR15 : %08lx\n",
|
|
esr15, ear15);
|
|
|
|
info.si_signo = SIGSEGV;
|
|
info.si_code = SEGV_ACCERR;
|
|
info.si_errno = 0;
|
|
info.si_addr = (void __user *)
|
|
(((esr15 & (ESRx_VALID|ESR15_EAV)) == (ESRx_VALID|ESR15_EAV)) ? ear15 : 0);
|
|
|
|
force_sig_info(info.si_signo, &info, current);
|
|
} /* end data_access_error() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* data store error - should only happen if accessing inactive or self-refreshing SDRAM
|
|
*/
|
|
asmlinkage void data_store_error(unsigned long esfr1, unsigned long esr15)
|
|
{
|
|
die_if_kernel("-- Data Store Error --\n"
|
|
"ESR15 : %08lx\n",
|
|
esr15);
|
|
BUG();
|
|
} /* end data_store_error() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
*
|
|
*/
|
|
asmlinkage void division_exception(unsigned long esfr1, unsigned long esr0, unsigned long isr)
|
|
{
|
|
siginfo_t info;
|
|
|
|
die_if_kernel("-- Division Exception --\n"
|
|
"ESR0 : %08lx\n"
|
|
"ISR : %08lx\n",
|
|
esr0, isr);
|
|
|
|
info.si_signo = SIGFPE;
|
|
info.si_code = FPE_INTDIV;
|
|
info.si_errno = 0;
|
|
info.si_addr = (void __user *) __frame->pc;
|
|
|
|
force_sig_info(info.si_signo, &info, current);
|
|
} /* end division_exception() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
*
|
|
*/
|
|
asmlinkage void compound_exception(unsigned long esfr1,
|
|
unsigned long esr0, unsigned long esr14, unsigned long esr15,
|
|
unsigned long msr0, unsigned long msr1)
|
|
{
|
|
die_if_kernel("-- Compound Exception --\n"
|
|
"ESR0 : %08lx\n"
|
|
"ESR15 : %08lx\n"
|
|
"ESR15 : %08lx\n"
|
|
"MSR0 : %08lx\n"
|
|
"MSR1 : %08lx\n",
|
|
esr0, esr14, esr15, msr0, msr1);
|
|
BUG();
|
|
} /* end compound_exception() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* The architecture-independent backtrace generator
|
|
*/
|
|
void dump_stack(void)
|
|
{
|
|
show_stack(NULL, NULL);
|
|
}
|
|
|
|
EXPORT_SYMBOL(dump_stack);
|
|
|
|
void show_stack(struct task_struct *task, unsigned long *sp)
|
|
{
|
|
}
|
|
|
|
void show_trace_task(struct task_struct *tsk)
|
|
{
|
|
printk("CONTEXT: stack=0x%lx frame=0x%p LR=0x%lx RET=0x%lx\n",
|
|
tsk->thread.sp, tsk->thread.frame, tsk->thread.lr, tsk->thread.sched_lr);
|
|
}
|
|
|
|
static const char *regnames[] = {
|
|
"PSR ", "ISR ", "CCR ", "CCCR",
|
|
"LR ", "LCR ", "PC ", "_stt",
|
|
"sys ", "GR8*", "GNE0", "GNE1",
|
|
"IACH", "IACL",
|
|
"TBR ", "SP ", "FP ", "GR3 ",
|
|
"GR4 ", "GR5 ", "GR6 ", "GR7 ",
|
|
"GR8 ", "GR9 ", "GR10", "GR11",
|
|
"GR12", "GR13", "GR14", "GR15",
|
|
"GR16", "GR17", "GR18", "GR19",
|
|
"GR20", "GR21", "GR22", "GR23",
|
|
"GR24", "GR25", "GR26", "GR27",
|
|
"EFRM", "CURR", "GR30", "BFRM"
|
|
};
|
|
|
|
void show_regs(struct pt_regs *regs)
|
|
{
|
|
unsigned long *reg;
|
|
int loop;
|
|
|
|
printk("\n");
|
|
|
|
printk("Frame: @%08lx [%s]\n",
|
|
(unsigned long) regs,
|
|
regs->psr & PSR_S ? "kernel" : "user");
|
|
|
|
reg = (unsigned long *) regs;
|
|
for (loop = 0; loop < NR_PT_REGS; loop++) {
|
|
printk("%s %08lx", regnames[loop + 0], reg[loop + 0]);
|
|
|
|
if (loop == NR_PT_REGS - 1 || loop % 5 == 4)
|
|
printk("\n");
|
|
else
|
|
printk(" | ");
|
|
}
|
|
|
|
printk("Process %s (pid: %d)\n", current->comm, current->pid);
|
|
}
|
|
|
|
void die_if_kernel(const char *str, ...)
|
|
{
|
|
char buffer[256];
|
|
va_list va;
|
|
|
|
if (user_mode(__frame))
|
|
return;
|
|
|
|
va_start(va, str);
|
|
vsprintf(buffer, str, va);
|
|
va_end(va);
|
|
|
|
console_verbose();
|
|
printk("\n===================================\n");
|
|
printk("%s\n", buffer);
|
|
show_backtrace(__frame, 0);
|
|
|
|
__break_hijack_kernel_event();
|
|
do_exit(SIGSEGV);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* dump the contents of an exception frame
|
|
*/
|
|
static void show_backtrace_regs(struct pt_regs *frame)
|
|
{
|
|
unsigned long *reg;
|
|
int loop;
|
|
|
|
/* print the registers for this frame */
|
|
printk("<-- %s Frame: @%p -->\n",
|
|
frame->psr & PSR_S ? "Kernel Mode" : "User Mode",
|
|
frame);
|
|
|
|
reg = (unsigned long *) frame;
|
|
for (loop = 0; loop < NR_PT_REGS; loop++) {
|
|
printk("%s %08lx", regnames[loop + 0], reg[loop + 0]);
|
|
|
|
if (loop == NR_PT_REGS - 1 || loop % 5 == 4)
|
|
printk("\n");
|
|
else
|
|
printk(" | ");
|
|
}
|
|
|
|
printk("--------\n");
|
|
} /* end show_backtrace_regs() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* generate a backtrace of the kernel stack
|
|
*/
|
|
void show_backtrace(struct pt_regs *frame, unsigned long sp)
|
|
{
|
|
struct pt_regs *frame0;
|
|
unsigned long tos = 0, stop = 0, base;
|
|
int format;
|
|
|
|
base = ((((unsigned long) frame) + 8191) & ~8191) - sizeof(struct user_context);
|
|
frame0 = (struct pt_regs *) base;
|
|
|
|
if (sp) {
|
|
tos = sp;
|
|
stop = (unsigned long) frame;
|
|
}
|
|
|
|
printk("\nProcess %s (pid: %d)\n\n", current->comm, current->pid);
|
|
|
|
for (;;) {
|
|
/* dump stack segment between frames */
|
|
//printk("%08lx -> %08lx\n", tos, stop);
|
|
format = 0;
|
|
while (tos < stop) {
|
|
if (format == 0)
|
|
printk(" %04lx :", tos & 0xffff);
|
|
|
|
printk(" %08lx", *(unsigned long *) tos);
|
|
|
|
tos += 4;
|
|
format++;
|
|
if (format == 8) {
|
|
printk("\n");
|
|
format = 0;
|
|
}
|
|
}
|
|
|
|
if (format > 0)
|
|
printk("\n");
|
|
|
|
/* dump frame 0 outside of the loop */
|
|
if (frame == frame0)
|
|
break;
|
|
|
|
tos = frame->sp;
|
|
if (((unsigned long) frame) + sizeof(*frame) != tos) {
|
|
printk("-- TOS %08lx does not follow frame %p --\n",
|
|
tos, frame);
|
|
break;
|
|
}
|
|
|
|
show_backtrace_regs(frame);
|
|
|
|
/* dump the stack between this frame and the next */
|
|
stop = (unsigned long) frame->next_frame;
|
|
if (stop != base &&
|
|
(stop < tos ||
|
|
stop > base ||
|
|
(stop < base && stop + sizeof(*frame) > base) ||
|
|
stop & 3)) {
|
|
printk("-- next_frame %08lx is invalid (range %08lx-%08lx) --\n",
|
|
stop, tos, base);
|
|
break;
|
|
}
|
|
|
|
/* move to next frame */
|
|
frame = frame->next_frame;
|
|
}
|
|
|
|
/* we can always dump frame 0, even if the rest of the stack is corrupt */
|
|
show_backtrace_regs(frame0);
|
|
|
|
} /* end show_backtrace() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* initialise traps
|
|
*/
|
|
void __init trap_init (void)
|
|
{
|
|
} /* end trap_init() */
|