void
print_trapframe(struct Trapframe *tf)
{
cprintf("TRAP frame at %p from CPU %d\n", tf, cpunum());
print_regs(&tf->tf_regs);
cprintf(" es 0x----%04x\n", tf->tf_es);
cprintf(" ds 0x----%04x\n", tf->tf_ds);
cprintf(" trap 0x%08x %s\n", tf->tf_trapno, trapname(tf->tf_trapno));
// If this trap was a page fault that just happened
// (so %cr2 is meaningful), print the faulting linear address.
if (tf == last_tf && tf->tf_trapno == T_PGFLT)
cprintf(" cr2 0x%08x\n", rcr2());
cprintf(" err 0x%08x", tf->tf_err);
// For page faults, print decoded fault error code:
// U/K=fault occurred in user/kernel mode
// W/R=a write/read caused the fault
// PR=a protection violation caused the fault (NP=page not present).
if (tf->tf_trapno == T_PGFLT)
cprintf(" [%s, %s, %s]\n",
tf->tf_err & 4 ? "user" : "kernel",
tf->tf_err & 2 ? "write" : "read",
tf->tf_err & 1 ? "protection" : "not-present");
else
cprintf("\n");
cprintf(" eip 0x%08x\n", tf->tf_eip);
cprintf(" cs 0x----%04x\n", tf->tf_cs);
cprintf(" flag 0x%08x\n", tf->tf_eflags);
if ((tf->tf_cs & 3) != 0) {
cprintf(" esp 0x%08x\n", tf->tf_esp);
cprintf(" ss 0x----%04x\n", tf->tf_ss);
}
}
void
print_trapframe(struct trapframe *tf) {
cprintf("trapframe at %p\n", tf);
print_regs(&tf->tf_regs);
cprintf(" ds 0x----%04x\n", tf->tf_ds);
cprintf(" es 0x----%04x\n", tf->tf_es);
cprintf(" fs 0x----%04x\n", tf->tf_fs);
cprintf(" gs 0x----%04x\n", tf->tf_gs);
cprintf(" trap 0x%08x %s\n", tf->tf_trapno, trapname(tf->tf_trapno));
cprintf(" err 0x%08x\n", tf->tf_err);
cprintf(" eip 0x%08x\n", tf->tf_eip);
cprintf(" cs 0x----%04x\n", tf->tf_cs);
cprintf(" flag 0x%08x ", tf->tf_eflags);
int i, j;
for (i = 0, j = 1; i < sizeof(IA32flags) / sizeof(IA32flags[0]); i ++, j <<= 1) {
if ((tf->tf_eflags & j) && IA32flags[i] != NULL) {
cprintf("%s,", IA32flags[i]);
}
}
cprintf("IOPL=%d\n", (tf->tf_eflags & FL_IOPL_MASK) >> 12);
if (!trap_in_kernel(tf)) {
cprintf(" esp 0x%08x\n", tf->tf_esp);
cprintf(" ss 0x----%04x\n", tf->tf_ss);
}
}
static void
printtrap(u_int vector, struct trapframe *frame, int isfatal, int user)
{
register_t va = 0;
printf("\n");
printf("%s %s trap:\n", isfatal ? "fatal" : "handled",
user ? "user" : "kernel");
printf("\n");
printf(" exception = 0x%x (%s)\n", vector, trapname(vector));
switch (vector) {
case EXC_DTMISS:
case EXC_DSI:
va = frame->cpu.booke.dear;
break;
case EXC_ITMISS:
case EXC_ISI:
va = frame->srr0;
break;
}
printf(" virtual address = 0x%08x\n", va);
printf(" srr0 = 0x%08x\n", frame->srr0);
printf(" srr1 = 0x%08x\n", frame->srr1);
printf(" curthread = %p\n", curthread);
if (curthread != NULL)
printf(" pid = %d, comm = %s\n",
curthread->td_proc->p_pid, curthread->td_proc->p_comm);
printf("\n");
}
void print_trapframe(struct trapframe *tf)
{
kprintf("trapframe at %p\n", tf);
print_regs(&tf->tf_regs);
kprintf(" usr_lr 0x%08x\n", tf->__tf_user_lr);
kprintf(" sp 0x%08x\n", tf->tf_esp);
kprintf(" lr 0x%08x\n", tf->tf_epc);
kprintf(" spsr 0x%08x %s\n", tf->tf_sr, modenames[tf->tf_sr & 0xF]);
kprintf(" trap 0x%08x %s\n", tf->tf_trapno, trapname(tf->tf_trapno));
kprintf(" err 0x%08x\n", tf->tf_err);
}
static void
trap_fatal(struct trapframe *frame)
{
printtrap(frame->exc, frame, 1, (frame->srr1 & PSL_PR));
#ifdef KDB
if ((debugger_on_panic || kdb_active) &&
kdb_trap(frame->exc, 0, frame))
return;
#endif
panic("%s trap", trapname(frame->exc));
}
void
print_trapframe(struct Trapframe *tf)
{
cprintf("TRAP frame at %p\n", tf);
print_regs(&tf->tf_regs);
cprintf(" es 0x----%04x\n", tf->tf_es);
cprintf(" ds 0x----%04x\n", tf->tf_ds);
cprintf(" trap 0x%08x %s\n", tf->tf_trapno, trapname(tf->tf_trapno));
cprintf(" err 0x%08x\n", tf->tf_err);
cprintf(" eip 0x%08x\n", tf->tf_eip);
cprintf(" cs 0x----%04x\n", tf->tf_cs);
cprintf(" flag 0x%08x\n", tf->tf_eflags);
cprintf(" esp 0x%08x\n", tf->tf_esp);
cprintf(" ss 0x----%04x\n", tf->tf_ss);
}
void print_trapframe(struct trapframe *tf)
{
PRINT_HEX("trapframe at ", tf);
print_regs(&tf->tf_regs);
PRINT_HEX(" $ra\t: ", tf->tf_ra);
PRINT_HEX(" BadVA\t: ", tf->tf_vaddr);
PRINT_HEX(" Status\t: ", tf->tf_status);
PRINT_HEX(" Cause\t: ", tf->tf_cause);
PRINT_HEX(" EPC\t: ", tf->tf_epc);
if (!trap_in_kernel(tf)) {
kprintf("Trap in usermode: ");
} else {
kprintf("Trap in kernel: ");
}
kprintf(trapname(GET_CAUSE_EXCODE(tf->tf_cause)));
kputchar('\n');
}
void
print_trapframe(struct Trapframe *tf)
{
printf("TRAP frame at %p\n", tf);
printf(" edi 0x%08x\n", tf->tf_edi);
printf(" esi 0x%08x\n", tf->tf_esi);
printf(" ebp 0x%08x\n", tf->tf_ebp);
printf(" oesp 0x%08x\n", tf->tf_oesp);
printf(" ebx 0x%08x\n", tf->tf_ebx);
printf(" edx 0x%08x\n", tf->tf_edx);
printf(" ecx 0x%08x\n", tf->tf_ecx);
printf(" eax 0x%08x\n", tf->tf_eax);
printf(" es 0x----%04x\n", tf->tf_es);
printf(" ds 0x----%04x\n", tf->tf_ds);
printf(" trap 0x%08x %s\n", tf->tf_trapno, trapname(tf->tf_trapno));
printf(" err 0x%08x\n", tf->tf_err);
printf(" eip 0x%08x\n", tf->tf_eip);
printf(" cs 0x----%04x\n", tf->tf_cs);
printf(" flag 0x%08x\n", tf->tf_eflags);
printf(" esp 0x%08x\n", tf->tf_esp);
printf(" ss 0x----%04x\n", tf->tf_ss);
}
void
print_trapframe(struct trapframe *tf) {
PRINT_HEX("trapframe at ", tf);
print_regs(&tf->tf_regs);
PRINT_HEX(" $ra\t: ", tf->tf_ra);
PRINT_HEX(" BadVA\t: ", tf->tf_vaddr);
PRINT_HEX(" Status\t: ", tf->tf_status);
PRINT_HEX(" Cause\t: ", tf->tf_cause);
PRINT_HEX(" EPC\t: ", tf->tf_epc);
if (!trap_in_kernel(tf)) {
kprintf("Trap in usermode: ");
}else{
kprintf("Trap in kernel: ");
}
kprintf(trapname(GET_CAUSE_EXCODE(tf->tf_cause)));
kputchar('\n');
// /*
int i;
for (i = 0; i < 20; ++i) {
int *addr = (int*)(tf->tf_epc + i * 4);
kprintf("0x%08x=0x%08x\n", addr, *addr);
}
// */
}
void
print_trapframe(struct trapframe *tf)
{
cprintf("TRAP frame at %p\n", tf);
cprintf(" edi 0x%x\n", tf->edi);
cprintf(" esi 0x%x\n", tf->esi);
cprintf(" ebp 0x%x\n", tf->ebp);
cprintf(" oesp 0x%x\n", tf->oesp);
cprintf(" ebx 0x%x\n", tf->ebx);
cprintf(" edx 0x%x\n", tf->edx);
cprintf(" ecx 0x%x\n", tf->ecx);
cprintf(" eax 0x%x\n", tf->eax);
cprintf(" es 0x----%x\n", tf->es);
cprintf(" ds 0x----%x\n", tf->ds);
cprintf(" trap 0x%x %s\n", tf->trapno, trapname(tf->trapno));
cprintf(" err 0x%x\n", tf->err);
cprintf(" eip 0x%x\n", tf->eip);
cprintf(" cs 0x----%x\n", tf->cs);
cprintf(" flag 0x%x\n", tf->eflags);
cprintf(" esp 0x%x\n", tf->esp);
cprintf(" ss 0x----%x\n", tf->ss);
}
void
trap(struct trapframe *frame)
{
struct thread *td;
struct proc *p;
int sig, type, user;
ksiginfo_t ksi;
#ifdef KDB
if (kdb_active) {
kdb_reenter();
return;
}
#endif
PCPU_INC(cnt.v_trap);
td = curthread;
p = td->td_proc;
type = frame->exc;
sig = 0;
user = (frame->srr1 & PSL_PR) ? 1 : 0;
CTR3(KTR_TRAP, "trap: %s type=%s (%s)", p->p_comm,
trapname(type), user ? "user" : "kernel");
if (user) {
td->td_frame = frame;
if (td->td_ucred != p->p_ucred)
cred_update_thread(td);
/* User Mode Traps */
switch (type) {
case EXC_DSI:
case EXC_ISI:
sig = trap_pfault(frame, 1);
break;
case EXC_SC:
syscall(frame);
break;
case EXC_ALI:
if (fix_unaligned(td, frame) != 0)
sig = SIGBUS;
else
frame->srr0 += 4;
break;
case EXC_DEBUG: /* Single stepping */
mtspr(SPR_DBSR, mfspr(SPR_DBSR));
frame->srr1 &= ~PSL_DE;
frame->cpu.booke.dbcr0 &= ~(DBCR0_IDM || DBCR0_IC);
sig = SIGTRAP;
break;
case EXC_PGM: /* Program exception */
#ifdef FPU_EMU
sig = fpu_emulate(frame,
(struct fpreg *)&td->td_pcb->pcb_fpu);
#else
/* XXX SIGILL for non-trap instructions. */
sig = SIGTRAP;
#endif
break;
default:
trap_fatal(frame);
}
} else {
/* Kernel Mode Traps */
KASSERT(cold || td->td_ucred != NULL,
("kernel trap doesn't have ucred"));
switch (type) {
case EXC_DEBUG:
mtspr(SPR_DBSR, mfspr(SPR_DBSR));
kdb_trap(frame->exc, 0, frame);
return;
case EXC_DSI:
if (trap_pfault(frame, 0) == 0)
return;
break;
case EXC_MCHK:
if (handle_onfault(frame))
return;
break;
#ifdef KDB
case EXC_PGM:
if (frame->cpu.booke.esr & ESR_PTR)
kdb_trap(EXC_PGM, 0, frame);
return;
#endif
default:
break;
}
trap_fatal(frame);
}
if (sig != 0) {
if (p->p_sysent->sv_transtrap != NULL)
sig = (p->p_sysent->sv_transtrap)(sig, type);
ksiginfo_init_trap(&ksi);
ksi.ksi_signo = sig;
ksi.ksi_code = type; /* XXX, not POSIX */
/* ksi.ksi_addr = ? */
ksi.ksi_trapno = type;
trapsignal(td, &ksi);
}
userret(td, frame);
}
void
trap(Ureg *ureg)
{
int rem, itype, t;
if(up != nil)
rem = ((char*)ureg)-up->kstack;
else rem = ((char*)ureg)-(char*)m->stack;
if(ureg->type != PsrMfiq && rem < 256) {
dumpregs(ureg);
panic("trap %d stack bytes remaining (%s), "
"up=#%8.8lux ureg=#%8.8lux pc=#%8.8ux"
,rem, up?up->text:"", up, ureg, ureg->pc);
for(;;);
}
itype = ureg->type;
/* All interrupts/exceptions should be resumed at ureg->pc-4,
except for Data Abort which resumes at ureg->pc-8. */
if(itype == PsrMabt+1)
ureg->pc -= 8;
else ureg->pc -= 4;
if(up){
up->pc = ureg->pc;
up->dbgreg = ureg;
}
switch(itype) {
case PsrMirq:
t = m->ticks; /* CPU time per proc */
up = nil; /* no process at interrupt level */
irq(ureg);
up = m->proc;
preemption(m->ticks - t);
m->intr++;
break;
case PsrMund:
if(*(ulong*)ureg->pc == BREAK && breakhandler) {
int s;
Proc *p;
p = up;
s = breakhandler(ureg, p);
if(s == BrkSched) {
p->preempted = 0;
sched();
} else if(s == BrkNoSched) {
/* stop it being preempted until next instruction */
p->preempted = 1;
if(up)
up->dbgreg = 0;
return;
}
break;
}
if(up == nil) goto faultpanic;
spllo();
if(waserror()) {
if(waslo(ureg->psr) && up->type == Interp)
disfault(ureg, up->env->errstr);
setpanic();
dumpregs(ureg);
panic("%s", up->env->errstr);
}
if(!fpiarm(ureg)) {
dumpregs(ureg);
sys_trap_error(ureg->type);
}
poperror();
break;
case PsrMsvc: /* Jump through 0 or SWI */
if(waslo(ureg->psr) && up && up->type == Interp) {
spllo();
dumpregs(ureg);
sys_trap_error(ureg->type);
}
setpanic();
dumpregs(ureg);
panic("SVC/SWI exception");
break;
case PsrMabt: /* Prefetch abort */
if(catchdbg && catchdbg(ureg, 0))
break;
/* FALL THROUGH */
case PsrMabt+1: /* Data abort */
if(waslo(ureg->psr) && up && up->type == Interp) {
spllo();
faultarm(ureg);
}
print("Data Abort\n");
/* FALL THROUGH */
default:
faultpanic:
setpanic();
dumpregs(ureg);
panic("exception %uX %s\n", ureg->type, trapname(ureg->type));
break;
}
splhi();
if(up)
up->dbgreg = 0; /* becomes invalid after return from trap */
}
void
trap(struct trapframe *frame)
{
struct thread *td;
struct proc *p;
#ifdef KDTRACE_HOOKS
uint32_t inst;
#endif
int sig, type, user;
u_int ucode;
ksiginfo_t ksi;
PCPU_INC(cnt.v_trap);
td = curthread;
p = td->td_proc;
type = ucode = frame->exc;
sig = 0;
user = frame->srr1 & PSL_PR;
CTR3(KTR_TRAP, "trap: %s type=%s (%s)", td->td_name,
trapname(type), user ? "user" : "kernel");
#ifdef KDTRACE_HOOKS
/*
* A trap can occur while DTrace executes a probe. Before
* executing the probe, DTrace blocks re-scheduling and sets
* a flag in its per-cpu flags to indicate that it doesn't
* want to fault. On returning from the probe, the no-fault
* flag is cleared and finally re-scheduling is enabled.
*
* If the DTrace kernel module has registered a trap handler,
* call it and if it returns non-zero, assume that it has
* handled the trap and modified the trap frame so that this
* function can return normally.
*/
if (dtrace_trap_func != NULL && (*dtrace_trap_func)(frame, type) != 0)
return;
#endif
if (user) {
td->td_pticks = 0;
td->td_frame = frame;
if (td->td_cowgen != p->p_cowgen)
thread_cow_update(td);
/* User Mode Traps */
switch (type) {
case EXC_RUNMODETRC:
case EXC_TRC:
frame->srr1 &= ~PSL_SE;
sig = SIGTRAP;
ucode = TRAP_TRACE;
break;
#ifdef __powerpc64__
case EXC_ISE:
case EXC_DSE:
if (handle_user_slb_spill(&p->p_vmspace->vm_pmap,
(type == EXC_ISE) ? frame->srr0 : frame->dar) != 0){
sig = SIGSEGV;
ucode = SEGV_MAPERR;
}
break;
#endif
case EXC_DSI:
case EXC_ISI:
sig = trap_pfault(frame, 1);
if (sig == SIGSEGV)
ucode = SEGV_MAPERR;
break;
case EXC_SC:
syscall(frame);
break;
case EXC_FPU:
KASSERT((td->td_pcb->pcb_flags & PCB_FPU) != PCB_FPU,
("FPU already enabled for thread"));
enable_fpu(td);
break;
case EXC_VEC:
KASSERT((td->td_pcb->pcb_flags & PCB_VEC) != PCB_VEC,
("Altivec already enabled for thread"));
enable_vec(td);
break;
case EXC_VSX:
KASSERT((td->td_pcb->pcb_flags & PCB_VSX) != PCB_VSX,
("VSX already enabled for thread"));
if (!(td->td_pcb->pcb_flags & PCB_VEC))
enable_vec(td);
if (!(td->td_pcb->pcb_flags & PCB_FPU))
save_fpu(td);
td->td_pcb->pcb_flags |= PCB_VSX;
enable_fpu(td);
break;
case EXC_VECAST_G4:
case EXC_VECAST_G5:
/*
* We get a VPU assist exception for IEEE mode
* vector operations on denormalized floats.
* Emulating this is a giant pain, so for now,
* just switch off IEEE mode and treat them as
* zero.
*/
save_vec(td);
td->td_pcb->pcb_vec.vscr |= ALTIVEC_VSCR_NJ;
enable_vec(td);
break;
case EXC_ALI:
if (fix_unaligned(td, frame) != 0) {
sig = SIGBUS;
ucode = BUS_ADRALN;
}
else
frame->srr0 += 4;
break;
case EXC_DEBUG: /* Single stepping */
mtspr(SPR_DBSR, mfspr(SPR_DBSR));
frame->srr1 &= ~PSL_DE;
frame->cpu.booke.dbcr0 &= ~(DBCR0_IDM || DBCR0_IC);
sig = SIGTRAP;
ucode = TRAP_TRACE;
break;
case EXC_PGM:
/* Identify the trap reason */
#ifdef AIM
if (frame->srr1 & EXC_PGM_TRAP) {
#else
if (frame->cpu.booke.esr & ESR_PTR) {
#endif
#ifdef KDTRACE_HOOKS
inst = fuword32((const void *)frame->srr0);
if (inst == 0x0FFFDDDD &&
dtrace_pid_probe_ptr != NULL) {
struct reg regs;
fill_regs(td, ®s);
(*dtrace_pid_probe_ptr)(®s);
break;
}
#endif
sig = SIGTRAP;
ucode = TRAP_BRKPT;
} else {
sig = ppc_instr_emulate(frame, td->td_pcb);
if (sig == SIGILL) {
if (frame->srr1 & EXC_PGM_PRIV)
ucode = ILL_PRVOPC;
else if (frame->srr1 & EXC_PGM_ILLEGAL)
ucode = ILL_ILLOPC;
} else if (sig == SIGFPE)
ucode = FPE_FLTINV; /* Punt for now, invalid operation. */
}
break;
case EXC_MCHK:
/*
* Note that this may not be recoverable for the user
* process, depending on the type of machine check,
* but it at least prevents the kernel from dying.
*/
sig = SIGBUS;
ucode = BUS_OBJERR;
break;
default:
trap_fatal(frame);
}
} else {
/* Kernel Mode Traps */
KASSERT(cold || td->td_ucred != NULL,
("kernel trap doesn't have ucred"));
switch (type) {
#ifdef KDTRACE_HOOKS
case EXC_PGM:
if (frame->srr1 & EXC_PGM_TRAP) {
if (*(uint32_t *)frame->srr0 == EXC_DTRACE) {
if (dtrace_invop_jump_addr != NULL) {
dtrace_invop_jump_addr(frame);
return;
}
}
}
break;
#endif
#ifdef __powerpc64__
case EXC_DSE:
if ((frame->dar & SEGMENT_MASK) == USER_ADDR) {
__asm __volatile ("slbmte %0, %1" ::
"r"(td->td_pcb->pcb_cpu.aim.usr_vsid),
"r"(USER_SLB_SLBE));
return;
}
break;
#endif
case EXC_DSI:
if (trap_pfault(frame, 0) == 0)
return;
break;
case EXC_MCHK:
if (handle_onfault(frame))
return;
break;
default:
break;
}
trap_fatal(frame);
}
