128cbb9b1SJustin Hibbits /*- 228cbb9b1SJustin Hibbits * Copyright (C) 1995, 1996 Wolfgang Solfrank. 328cbb9b1SJustin Hibbits * Copyright (C) 1995, 1996 TooLs GmbH. 428cbb9b1SJustin Hibbits * All rights reserved. 528cbb9b1SJustin Hibbits * 628cbb9b1SJustin Hibbits * Redistribution and use in source and binary forms, with or without 728cbb9b1SJustin Hibbits * modification, are permitted provided that the following conditions 828cbb9b1SJustin Hibbits * are met: 928cbb9b1SJustin Hibbits * 1. Redistributions of source code must retain the above copyright 1028cbb9b1SJustin Hibbits * notice, this list of conditions and the following disclaimer. 1128cbb9b1SJustin Hibbits * 2. Redistributions in binary form must reproduce the above copyright 1228cbb9b1SJustin Hibbits * notice, this list of conditions and the following disclaimer in the 1328cbb9b1SJustin Hibbits * documentation and/or other materials provided with the distribution. 1428cbb9b1SJustin Hibbits * 3. All advertising materials mentioning features or use of this software 1528cbb9b1SJustin Hibbits * must display the following acknowledgement: 1628cbb9b1SJustin Hibbits * This product includes software developed by TooLs GmbH. 1728cbb9b1SJustin Hibbits * 4. The name of TooLs GmbH may not be used to endorse or promote products 1828cbb9b1SJustin Hibbits * derived from this software without specific prior written permission. 1928cbb9b1SJustin Hibbits * 2028cbb9b1SJustin Hibbits * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR 2128cbb9b1SJustin Hibbits * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 2228cbb9b1SJustin Hibbits * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 2328cbb9b1SJustin Hibbits * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 2428cbb9b1SJustin Hibbits * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 2528cbb9b1SJustin Hibbits * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 2628cbb9b1SJustin Hibbits * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 2728cbb9b1SJustin Hibbits * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 2828cbb9b1SJustin Hibbits * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 2928cbb9b1SJustin Hibbits * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 3028cbb9b1SJustin Hibbits * 3128cbb9b1SJustin Hibbits * $NetBSD: trap.c,v 1.58 2002/03/04 04:07:35 dbj Exp $ 3228cbb9b1SJustin Hibbits */ 3328cbb9b1SJustin Hibbits 3428cbb9b1SJustin Hibbits #include <sys/cdefs.h> 3528cbb9b1SJustin Hibbits __FBSDID("$FreeBSD$"); 3628cbb9b1SJustin Hibbits 3728cbb9b1SJustin Hibbits #include <sys/param.h> 3828cbb9b1SJustin Hibbits #include <sys/kdb.h> 3928cbb9b1SJustin Hibbits #include <sys/proc.h> 4028cbb9b1SJustin Hibbits #include <sys/ktr.h> 4128cbb9b1SJustin Hibbits #include <sys/lock.h> 4228cbb9b1SJustin Hibbits #include <sys/mutex.h> 4328cbb9b1SJustin Hibbits #include <sys/pioctl.h> 4428cbb9b1SJustin Hibbits #include <sys/ptrace.h> 4528cbb9b1SJustin Hibbits #include <sys/reboot.h> 4628cbb9b1SJustin Hibbits #include <sys/syscall.h> 4728cbb9b1SJustin Hibbits #include <sys/sysent.h> 4828cbb9b1SJustin Hibbits #include <sys/systm.h> 4928cbb9b1SJustin Hibbits #include <sys/kernel.h> 5028cbb9b1SJustin Hibbits #include <sys/uio.h> 5128cbb9b1SJustin Hibbits #include <sys/signalvar.h> 5228cbb9b1SJustin Hibbits #include <sys/vmmeter.h> 5328cbb9b1SJustin Hibbits 5428cbb9b1SJustin Hibbits #include <security/audit/audit.h> 5528cbb9b1SJustin Hibbits 5628cbb9b1SJustin Hibbits #include <vm/vm.h> 5728cbb9b1SJustin Hibbits #include <vm/pmap.h> 5828cbb9b1SJustin Hibbits #include <vm/vm_extern.h> 5928cbb9b1SJustin Hibbits #include <vm/vm_param.h> 6028cbb9b1SJustin Hibbits #include <vm/vm_kern.h> 6128cbb9b1SJustin Hibbits #include <vm/vm_map.h> 6228cbb9b1SJustin Hibbits #include <vm/vm_page.h> 6328cbb9b1SJustin Hibbits 6428cbb9b1SJustin Hibbits #include <machine/_inttypes.h> 6528cbb9b1SJustin Hibbits #include <machine/altivec.h> 6628cbb9b1SJustin Hibbits #include <machine/cpu.h> 6728cbb9b1SJustin Hibbits #include <machine/db_machdep.h> 6828cbb9b1SJustin Hibbits #include <machine/fpu.h> 6928cbb9b1SJustin Hibbits #include <machine/frame.h> 7028cbb9b1SJustin Hibbits #include <machine/pcb.h> 7128cbb9b1SJustin Hibbits #include <machine/psl.h> 7228cbb9b1SJustin Hibbits #include <machine/trap.h> 7328cbb9b1SJustin Hibbits #include <machine/spr.h> 7428cbb9b1SJustin Hibbits #include <machine/sr.h> 7528cbb9b1SJustin Hibbits 76a18c313eSNathan Whitehorn /* Below matches setjmp.S */ 77a18c313eSNathan Whitehorn #define FAULTBUF_LR 21 7828cbb9b1SJustin Hibbits #define FAULTBUF_R1 1 7928cbb9b1SJustin Hibbits #define FAULTBUF_R2 2 80a18c313eSNathan Whitehorn #define FAULTBUF_CR 22 81a18c313eSNathan Whitehorn #define FAULTBUF_R14 3 8228cbb9b1SJustin Hibbits 8328cbb9b1SJustin Hibbits static void trap_fatal(struct trapframe *frame); 8428cbb9b1SJustin Hibbits static void printtrap(u_int vector, struct trapframe *frame, int isfatal, 8528cbb9b1SJustin Hibbits int user); 8628cbb9b1SJustin Hibbits static int trap_pfault(struct trapframe *frame, int user); 8728cbb9b1SJustin Hibbits static int fix_unaligned(struct thread *td, struct trapframe *frame); 8828cbb9b1SJustin Hibbits static int handle_onfault(struct trapframe *frame); 8928cbb9b1SJustin Hibbits static void syscall(struct trapframe *frame); 9028cbb9b1SJustin Hibbits 9128cbb9b1SJustin Hibbits #ifdef __powerpc64__ 9228cbb9b1SJustin Hibbits void handle_kernel_slb_spill(int, register_t, register_t); 9328cbb9b1SJustin Hibbits static int handle_user_slb_spill(pmap_t pm, vm_offset_t addr); 9428cbb9b1SJustin Hibbits extern int n_slbs; 9528cbb9b1SJustin Hibbits #endif 9628cbb9b1SJustin Hibbits 9728cbb9b1SJustin Hibbits struct powerpc_exception { 9828cbb9b1SJustin Hibbits u_int vector; 9928cbb9b1SJustin Hibbits char *name; 10028cbb9b1SJustin Hibbits }; 10128cbb9b1SJustin Hibbits 10228cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS 10328cbb9b1SJustin Hibbits #include <sys/dtrace_bsd.h> 10428cbb9b1SJustin Hibbits 10528cbb9b1SJustin Hibbits int (*dtrace_invop_jump_addr)(struct trapframe *); 10628cbb9b1SJustin Hibbits #endif 10728cbb9b1SJustin Hibbits 10828cbb9b1SJustin Hibbits static struct powerpc_exception powerpc_exceptions[] = { 10928cbb9b1SJustin Hibbits { EXC_CRIT, "critical input" }, 11028cbb9b1SJustin Hibbits { EXC_RST, "system reset" }, 11128cbb9b1SJustin Hibbits { EXC_MCHK, "machine check" }, 11228cbb9b1SJustin Hibbits { EXC_DSI, "data storage interrupt" }, 11328cbb9b1SJustin Hibbits { EXC_DSE, "data segment exception" }, 11428cbb9b1SJustin Hibbits { EXC_ISI, "instruction storage interrupt" }, 11528cbb9b1SJustin Hibbits { EXC_ISE, "instruction segment exception" }, 11628cbb9b1SJustin Hibbits { EXC_EXI, "external interrupt" }, 11728cbb9b1SJustin Hibbits { EXC_ALI, "alignment" }, 11828cbb9b1SJustin Hibbits { EXC_PGM, "program" }, 11928cbb9b1SJustin Hibbits { EXC_FPU, "floating-point unavailable" }, 12028cbb9b1SJustin Hibbits { EXC_APU, "auxiliary proc unavailable" }, 12128cbb9b1SJustin Hibbits { EXC_DECR, "decrementer" }, 12228cbb9b1SJustin Hibbits { EXC_FIT, "fixed-interval timer" }, 12328cbb9b1SJustin Hibbits { EXC_WDOG, "watchdog timer" }, 12428cbb9b1SJustin Hibbits { EXC_SC, "system call" }, 12528cbb9b1SJustin Hibbits { EXC_TRC, "trace" }, 12628cbb9b1SJustin Hibbits { EXC_FPA, "floating-point assist" }, 12728cbb9b1SJustin Hibbits { EXC_DEBUG, "debug" }, 12828cbb9b1SJustin Hibbits { EXC_PERF, "performance monitoring" }, 12928cbb9b1SJustin Hibbits { EXC_VEC, "altivec unavailable" }, 13028cbb9b1SJustin Hibbits { EXC_VSX, "vsx unavailable" }, 13128cbb9b1SJustin Hibbits { EXC_ITMISS, "instruction tlb miss" }, 13228cbb9b1SJustin Hibbits { EXC_DLMISS, "data load tlb miss" }, 13328cbb9b1SJustin Hibbits { EXC_DSMISS, "data store tlb miss" }, 13428cbb9b1SJustin Hibbits { EXC_BPT, "instruction breakpoint" }, 13528cbb9b1SJustin Hibbits { EXC_SMI, "system management" }, 13628cbb9b1SJustin Hibbits { EXC_VECAST_G4, "altivec assist" }, 13728cbb9b1SJustin Hibbits { EXC_THRM, "thermal management" }, 13828cbb9b1SJustin Hibbits { EXC_RUNMODETRC, "run mode/trace" }, 13928cbb9b1SJustin Hibbits { EXC_LAST, NULL } 14028cbb9b1SJustin Hibbits }; 14128cbb9b1SJustin Hibbits 14228cbb9b1SJustin Hibbits static const char * 14328cbb9b1SJustin Hibbits trapname(u_int vector) 14428cbb9b1SJustin Hibbits { 14528cbb9b1SJustin Hibbits struct powerpc_exception *pe; 14628cbb9b1SJustin Hibbits 14728cbb9b1SJustin Hibbits for (pe = powerpc_exceptions; pe->vector != EXC_LAST; pe++) { 14828cbb9b1SJustin Hibbits if (pe->vector == vector) 14928cbb9b1SJustin Hibbits return (pe->name); 15028cbb9b1SJustin Hibbits } 15128cbb9b1SJustin Hibbits 15228cbb9b1SJustin Hibbits return ("unknown"); 15328cbb9b1SJustin Hibbits } 15428cbb9b1SJustin Hibbits 15528cbb9b1SJustin Hibbits void 15628cbb9b1SJustin Hibbits trap(struct trapframe *frame) 15728cbb9b1SJustin Hibbits { 15828cbb9b1SJustin Hibbits struct thread *td; 15928cbb9b1SJustin Hibbits struct proc *p; 16028cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS 16128cbb9b1SJustin Hibbits uint32_t inst; 16228cbb9b1SJustin Hibbits #endif 16328cbb9b1SJustin Hibbits int sig, type, user; 16428cbb9b1SJustin Hibbits u_int ucode; 16528cbb9b1SJustin Hibbits ksiginfo_t ksi; 16628cbb9b1SJustin Hibbits 16728cbb9b1SJustin Hibbits PCPU_INC(cnt.v_trap); 16828cbb9b1SJustin Hibbits 16928cbb9b1SJustin Hibbits td = curthread; 17028cbb9b1SJustin Hibbits p = td->td_proc; 17128cbb9b1SJustin Hibbits 17228cbb9b1SJustin Hibbits type = ucode = frame->exc; 17328cbb9b1SJustin Hibbits sig = 0; 17428cbb9b1SJustin Hibbits user = frame->srr1 & PSL_PR; 17528cbb9b1SJustin Hibbits 17628cbb9b1SJustin Hibbits CTR3(KTR_TRAP, "trap: %s type=%s (%s)", td->td_name, 17728cbb9b1SJustin Hibbits trapname(type), user ? "user" : "kernel"); 17828cbb9b1SJustin Hibbits 17928cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS 18028cbb9b1SJustin Hibbits /* 18128cbb9b1SJustin Hibbits * A trap can occur while DTrace executes a probe. Before 18228cbb9b1SJustin Hibbits * executing the probe, DTrace blocks re-scheduling and sets 18328cbb9b1SJustin Hibbits * a flag in its per-cpu flags to indicate that it doesn't 18428cbb9b1SJustin Hibbits * want to fault. On returning from the probe, the no-fault 18528cbb9b1SJustin Hibbits * flag is cleared and finally re-scheduling is enabled. 18628cbb9b1SJustin Hibbits * 18728cbb9b1SJustin Hibbits * If the DTrace kernel module has registered a trap handler, 18828cbb9b1SJustin Hibbits * call it and if it returns non-zero, assume that it has 18928cbb9b1SJustin Hibbits * handled the trap and modified the trap frame so that this 19028cbb9b1SJustin Hibbits * function can return normally. 19128cbb9b1SJustin Hibbits */ 19228cbb9b1SJustin Hibbits if (dtrace_trap_func != NULL && (*dtrace_trap_func)(frame, type) != 0) 19328cbb9b1SJustin Hibbits return; 19428cbb9b1SJustin Hibbits #endif 19528cbb9b1SJustin Hibbits 19628cbb9b1SJustin Hibbits if (user) { 19728cbb9b1SJustin Hibbits td->td_pticks = 0; 19828cbb9b1SJustin Hibbits td->td_frame = frame; 1994ea6a9a2SMateusz Guzik if (td->td_cowgen != p->p_cowgen) 2004ea6a9a2SMateusz Guzik thread_cow_update(td); 20128cbb9b1SJustin Hibbits 20228cbb9b1SJustin Hibbits /* User Mode Traps */ 20328cbb9b1SJustin Hibbits switch (type) { 20428cbb9b1SJustin Hibbits case EXC_RUNMODETRC: 20528cbb9b1SJustin Hibbits case EXC_TRC: 20628cbb9b1SJustin Hibbits frame->srr1 &= ~PSL_SE; 20728cbb9b1SJustin Hibbits sig = SIGTRAP; 20828cbb9b1SJustin Hibbits ucode = TRAP_TRACE; 20928cbb9b1SJustin Hibbits break; 21028cbb9b1SJustin Hibbits 21128cbb9b1SJustin Hibbits #ifdef __powerpc64__ 21228cbb9b1SJustin Hibbits case EXC_ISE: 21328cbb9b1SJustin Hibbits case EXC_DSE: 21428cbb9b1SJustin Hibbits if (handle_user_slb_spill(&p->p_vmspace->vm_pmap, 21528cbb9b1SJustin Hibbits (type == EXC_ISE) ? frame->srr0 : frame->dar) != 0){ 21628cbb9b1SJustin Hibbits sig = SIGSEGV; 21728cbb9b1SJustin Hibbits ucode = SEGV_MAPERR; 21828cbb9b1SJustin Hibbits } 21928cbb9b1SJustin Hibbits break; 22028cbb9b1SJustin Hibbits #endif 22128cbb9b1SJustin Hibbits case EXC_DSI: 22228cbb9b1SJustin Hibbits case EXC_ISI: 22328cbb9b1SJustin Hibbits sig = trap_pfault(frame, 1); 22428cbb9b1SJustin Hibbits if (sig == SIGSEGV) 22528cbb9b1SJustin Hibbits ucode = SEGV_MAPERR; 22628cbb9b1SJustin Hibbits break; 22728cbb9b1SJustin Hibbits 22828cbb9b1SJustin Hibbits case EXC_SC: 22928cbb9b1SJustin Hibbits syscall(frame); 23028cbb9b1SJustin Hibbits break; 23128cbb9b1SJustin Hibbits 23228cbb9b1SJustin Hibbits case EXC_FPU: 23328cbb9b1SJustin Hibbits KASSERT((td->td_pcb->pcb_flags & PCB_FPU) != PCB_FPU, 23428cbb9b1SJustin Hibbits ("FPU already enabled for thread")); 23528cbb9b1SJustin Hibbits enable_fpu(td); 23628cbb9b1SJustin Hibbits break; 23728cbb9b1SJustin Hibbits 23828cbb9b1SJustin Hibbits case EXC_VEC: 23928cbb9b1SJustin Hibbits KASSERT((td->td_pcb->pcb_flags & PCB_VEC) != PCB_VEC, 24028cbb9b1SJustin Hibbits ("Altivec already enabled for thread")); 24128cbb9b1SJustin Hibbits enable_vec(td); 24228cbb9b1SJustin Hibbits break; 24328cbb9b1SJustin Hibbits 24428cbb9b1SJustin Hibbits case EXC_VSX: 24528cbb9b1SJustin Hibbits KASSERT((td->td_pcb->pcb_flags & PCB_VSX) != PCB_VSX, 24628cbb9b1SJustin Hibbits ("VSX already enabled for thread")); 24728cbb9b1SJustin Hibbits if (!(td->td_pcb->pcb_flags & PCB_VEC)) 24828cbb9b1SJustin Hibbits enable_vec(td); 24928cbb9b1SJustin Hibbits if (!(td->td_pcb->pcb_flags & PCB_FPU)) 25028cbb9b1SJustin Hibbits save_fpu(td); 25128cbb9b1SJustin Hibbits td->td_pcb->pcb_flags |= PCB_VSX; 25228cbb9b1SJustin Hibbits enable_fpu(td); 25328cbb9b1SJustin Hibbits break; 25428cbb9b1SJustin Hibbits 255541c5806SJustin Hibbits case EXC_VECAST_E: 25628cbb9b1SJustin Hibbits case EXC_VECAST_G4: 25728cbb9b1SJustin Hibbits case EXC_VECAST_G5: 25828cbb9b1SJustin Hibbits /* 25928cbb9b1SJustin Hibbits * We get a VPU assist exception for IEEE mode 26028cbb9b1SJustin Hibbits * vector operations on denormalized floats. 26128cbb9b1SJustin Hibbits * Emulating this is a giant pain, so for now, 26228cbb9b1SJustin Hibbits * just switch off IEEE mode and treat them as 26328cbb9b1SJustin Hibbits * zero. 26428cbb9b1SJustin Hibbits */ 26528cbb9b1SJustin Hibbits 26628cbb9b1SJustin Hibbits save_vec(td); 26728cbb9b1SJustin Hibbits td->td_pcb->pcb_vec.vscr |= ALTIVEC_VSCR_NJ; 26828cbb9b1SJustin Hibbits enable_vec(td); 26928cbb9b1SJustin Hibbits break; 27028cbb9b1SJustin Hibbits 27128cbb9b1SJustin Hibbits case EXC_ALI: 27228cbb9b1SJustin Hibbits if (fix_unaligned(td, frame) != 0) { 27328cbb9b1SJustin Hibbits sig = SIGBUS; 27428cbb9b1SJustin Hibbits ucode = BUS_ADRALN; 27528cbb9b1SJustin Hibbits } 27628cbb9b1SJustin Hibbits else 27728cbb9b1SJustin Hibbits frame->srr0 += 4; 27828cbb9b1SJustin Hibbits break; 27928cbb9b1SJustin Hibbits 28028cbb9b1SJustin Hibbits case EXC_DEBUG: /* Single stepping */ 28128cbb9b1SJustin Hibbits mtspr(SPR_DBSR, mfspr(SPR_DBSR)); 28228cbb9b1SJustin Hibbits frame->srr1 &= ~PSL_DE; 28328cbb9b1SJustin Hibbits frame->cpu.booke.dbcr0 &= ~(DBCR0_IDM || DBCR0_IC); 28428cbb9b1SJustin Hibbits sig = SIGTRAP; 28528cbb9b1SJustin Hibbits ucode = TRAP_TRACE; 28628cbb9b1SJustin Hibbits break; 28728cbb9b1SJustin Hibbits 28828cbb9b1SJustin Hibbits case EXC_PGM: 28928cbb9b1SJustin Hibbits /* Identify the trap reason */ 29028cbb9b1SJustin Hibbits #ifdef AIM 29128cbb9b1SJustin Hibbits if (frame->srr1 & EXC_PGM_TRAP) { 29228cbb9b1SJustin Hibbits #else 29328cbb9b1SJustin Hibbits if (frame->cpu.booke.esr & ESR_PTR) { 29428cbb9b1SJustin Hibbits #endif 29528cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS 29628cbb9b1SJustin Hibbits inst = fuword32((const void *)frame->srr0); 29728cbb9b1SJustin Hibbits if (inst == 0x0FFFDDDD && 29828cbb9b1SJustin Hibbits dtrace_pid_probe_ptr != NULL) { 29928cbb9b1SJustin Hibbits struct reg regs; 30028cbb9b1SJustin Hibbits fill_regs(td, ®s); 30128cbb9b1SJustin Hibbits (*dtrace_pid_probe_ptr)(®s); 30228cbb9b1SJustin Hibbits break; 30328cbb9b1SJustin Hibbits } 30428cbb9b1SJustin Hibbits #endif 30528cbb9b1SJustin Hibbits sig = SIGTRAP; 30628cbb9b1SJustin Hibbits ucode = TRAP_BRKPT; 30728cbb9b1SJustin Hibbits } else { 30828cbb9b1SJustin Hibbits sig = ppc_instr_emulate(frame, td->td_pcb); 30928cbb9b1SJustin Hibbits if (sig == SIGILL) { 31028cbb9b1SJustin Hibbits if (frame->srr1 & EXC_PGM_PRIV) 31128cbb9b1SJustin Hibbits ucode = ILL_PRVOPC; 31228cbb9b1SJustin Hibbits else if (frame->srr1 & EXC_PGM_ILLEGAL) 31328cbb9b1SJustin Hibbits ucode = ILL_ILLOPC; 31428cbb9b1SJustin Hibbits } else if (sig == SIGFPE) 31528cbb9b1SJustin Hibbits ucode = FPE_FLTINV; /* Punt for now, invalid operation. */ 31628cbb9b1SJustin Hibbits } 31728cbb9b1SJustin Hibbits break; 31828cbb9b1SJustin Hibbits 31928cbb9b1SJustin Hibbits case EXC_MCHK: 32028cbb9b1SJustin Hibbits /* 32128cbb9b1SJustin Hibbits * Note that this may not be recoverable for the user 32228cbb9b1SJustin Hibbits * process, depending on the type of machine check, 32328cbb9b1SJustin Hibbits * but it at least prevents the kernel from dying. 32428cbb9b1SJustin Hibbits */ 32528cbb9b1SJustin Hibbits sig = SIGBUS; 32628cbb9b1SJustin Hibbits ucode = BUS_OBJERR; 32728cbb9b1SJustin Hibbits break; 32828cbb9b1SJustin Hibbits 32928cbb9b1SJustin Hibbits default: 33028cbb9b1SJustin Hibbits trap_fatal(frame); 33128cbb9b1SJustin Hibbits } 33228cbb9b1SJustin Hibbits } else { 33328cbb9b1SJustin Hibbits /* Kernel Mode Traps */ 33428cbb9b1SJustin Hibbits 33528cbb9b1SJustin Hibbits KASSERT(cold || td->td_ucred != NULL, 33628cbb9b1SJustin Hibbits ("kernel trap doesn't have ucred")); 33728cbb9b1SJustin Hibbits switch (type) { 33828cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS 33928cbb9b1SJustin Hibbits case EXC_PGM: 34028cbb9b1SJustin Hibbits if (frame->srr1 & EXC_PGM_TRAP) { 34128cbb9b1SJustin Hibbits if (*(uint32_t *)frame->srr0 == EXC_DTRACE) { 34228cbb9b1SJustin Hibbits if (dtrace_invop_jump_addr != NULL) { 34328cbb9b1SJustin Hibbits dtrace_invop_jump_addr(frame); 34428cbb9b1SJustin Hibbits return; 34528cbb9b1SJustin Hibbits } 34628cbb9b1SJustin Hibbits } 34728cbb9b1SJustin Hibbits } 34828cbb9b1SJustin Hibbits break; 34928cbb9b1SJustin Hibbits #endif 35028cbb9b1SJustin Hibbits #ifdef __powerpc64__ 35128cbb9b1SJustin Hibbits case EXC_DSE: 35228cbb9b1SJustin Hibbits if ((frame->dar & SEGMENT_MASK) == USER_ADDR) { 35328cbb9b1SJustin Hibbits __asm __volatile ("slbmte %0, %1" :: 35428cbb9b1SJustin Hibbits "r"(td->td_pcb->pcb_cpu.aim.usr_vsid), 35528cbb9b1SJustin Hibbits "r"(USER_SLB_SLBE)); 35628cbb9b1SJustin Hibbits return; 35728cbb9b1SJustin Hibbits } 35828cbb9b1SJustin Hibbits break; 35928cbb9b1SJustin Hibbits #endif 36028cbb9b1SJustin Hibbits case EXC_DSI: 36128cbb9b1SJustin Hibbits if (trap_pfault(frame, 0) == 0) 36228cbb9b1SJustin Hibbits return; 36328cbb9b1SJustin Hibbits break; 36428cbb9b1SJustin Hibbits case EXC_MCHK: 36528cbb9b1SJustin Hibbits if (handle_onfault(frame)) 36628cbb9b1SJustin Hibbits return; 36728cbb9b1SJustin Hibbits break; 36828cbb9b1SJustin Hibbits default: 36928cbb9b1SJustin Hibbits break; 37028cbb9b1SJustin Hibbits } 37128cbb9b1SJustin Hibbits trap_fatal(frame); 37228cbb9b1SJustin Hibbits } 37328cbb9b1SJustin Hibbits 37428cbb9b1SJustin Hibbits if (sig != 0) { 37528cbb9b1SJustin Hibbits if (p->p_sysent->sv_transtrap != NULL) 37628cbb9b1SJustin Hibbits sig = (p->p_sysent->sv_transtrap)(sig, type); 37728cbb9b1SJustin Hibbits ksiginfo_init_trap(&ksi); 37828cbb9b1SJustin Hibbits ksi.ksi_signo = sig; 37928cbb9b1SJustin Hibbits ksi.ksi_code = (int) ucode; /* XXX, not POSIX */ 38028cbb9b1SJustin Hibbits /* ksi.ksi_addr = ? */ 38128cbb9b1SJustin Hibbits ksi.ksi_trapno = type; 38228cbb9b1SJustin Hibbits trapsignal(td, &ksi); 38328cbb9b1SJustin Hibbits } 38428cbb9b1SJustin Hibbits 38528cbb9b1SJustin Hibbits userret(td, frame); 38628cbb9b1SJustin Hibbits } 38728cbb9b1SJustin Hibbits 38828cbb9b1SJustin Hibbits static void 38928cbb9b1SJustin Hibbits trap_fatal(struct trapframe *frame) 39028cbb9b1SJustin Hibbits { 39128cbb9b1SJustin Hibbits 39228cbb9b1SJustin Hibbits printtrap(frame->exc, frame, 1, (frame->srr1 & PSL_PR)); 39328cbb9b1SJustin Hibbits #ifdef KDB 39428cbb9b1SJustin Hibbits if ((debugger_on_panic || kdb_active) && 39528cbb9b1SJustin Hibbits kdb_trap(frame->exc, 0, frame)) 39628cbb9b1SJustin Hibbits return; 39728cbb9b1SJustin Hibbits #endif 39828cbb9b1SJustin Hibbits panic("%s trap", trapname(frame->exc)); 39928cbb9b1SJustin Hibbits } 40028cbb9b1SJustin Hibbits 40128cbb9b1SJustin Hibbits static void 40228cbb9b1SJustin Hibbits printtrap(u_int vector, struct trapframe *frame, int isfatal, int user) 40328cbb9b1SJustin Hibbits { 404398973f8SJustin Hibbits uint16_t ver; 4056035018bSJustin Hibbits #ifdef BOOKE 4066035018bSJustin Hibbits vm_paddr_t pa; 4076035018bSJustin Hibbits #endif 40828cbb9b1SJustin Hibbits 40928cbb9b1SJustin Hibbits printf("\n"); 41028cbb9b1SJustin Hibbits printf("%s %s trap:\n", isfatal ? "fatal" : "handled", 41128cbb9b1SJustin Hibbits user ? "user" : "kernel"); 41228cbb9b1SJustin Hibbits printf("\n"); 41328cbb9b1SJustin Hibbits printf(" exception = 0x%x (%s)\n", vector, trapname(vector)); 41428cbb9b1SJustin Hibbits switch (vector) { 41528cbb9b1SJustin Hibbits case EXC_DSE: 41628cbb9b1SJustin Hibbits case EXC_DSI: 41739a4b70fSJustin Hibbits case EXC_DTMISS: 41828cbb9b1SJustin Hibbits printf(" virtual address = 0x%" PRIxPTR "\n", frame->dar); 41939a4b70fSJustin Hibbits #ifdef AIM 420cf5aa326SJustin Hibbits printf(" dsisr = 0x%lx\n", 421cf5aa326SJustin Hibbits (u_long)frame->cpu.aim.dsisr); 42239a4b70fSJustin Hibbits #endif 42328cbb9b1SJustin Hibbits break; 42428cbb9b1SJustin Hibbits case EXC_ISE: 42528cbb9b1SJustin Hibbits case EXC_ISI: 42639a4b70fSJustin Hibbits case EXC_ITMISS: 42728cbb9b1SJustin Hibbits printf(" virtual address = 0x%" PRIxPTR "\n", frame->srr0); 42828cbb9b1SJustin Hibbits break; 429398973f8SJustin Hibbits case EXC_MCHK: 430398973f8SJustin Hibbits ver = mfpvr() >> 16; 431398973f8SJustin Hibbits #if defined(AIM) 432398973f8SJustin Hibbits if (MPC745X_P(ver)) 43344027a83SJustin Hibbits printf(" msssr0 = 0x%lx\n", 43444027a83SJustin Hibbits (u_long)mfspr(SPR_MSSSR0)); 435398973f8SJustin Hibbits #elif defined(BOOKE) 4366035018bSJustin Hibbits pa = mfspr(SPR_MCARU); 43701a40173SJustin Hibbits pa = (pa << 32) | (u_register_t)mfspr(SPR_MCAR); 43844027a83SJustin Hibbits printf(" mcsr = 0x%lx\n", (u_long)mfspr(SPR_MCSR)); 4396035018bSJustin Hibbits printf(" mcar = 0x%jx\n", (uintmax_t)pa); 440398973f8SJustin Hibbits #endif 441398973f8SJustin Hibbits break; 44228cbb9b1SJustin Hibbits } 44339a4b70fSJustin Hibbits #ifdef BOOKE 44439a4b70fSJustin Hibbits printf(" esr = 0x%" PRIxPTR "\n", 44539a4b70fSJustin Hibbits frame->cpu.booke.esr); 44639a4b70fSJustin Hibbits #endif 44728cbb9b1SJustin Hibbits printf(" srr0 = 0x%" PRIxPTR "\n", frame->srr0); 448cf5aa326SJustin Hibbits printf(" srr1 = 0x%lx\n", (u_long)frame->srr1); 44928cbb9b1SJustin Hibbits printf(" lr = 0x%" PRIxPTR "\n", frame->lr); 45028cbb9b1SJustin Hibbits printf(" curthread = %p\n", curthread); 45128cbb9b1SJustin Hibbits if (curthread != NULL) 45228cbb9b1SJustin Hibbits printf(" pid = %d, comm = %s\n", 45328cbb9b1SJustin Hibbits curthread->td_proc->p_pid, curthread->td_name); 45428cbb9b1SJustin Hibbits printf("\n"); 45528cbb9b1SJustin Hibbits } 45628cbb9b1SJustin Hibbits 45728cbb9b1SJustin Hibbits /* 45828cbb9b1SJustin Hibbits * Handles a fatal fault when we have onfault state to recover. Returns 45928cbb9b1SJustin Hibbits * non-zero if there was onfault recovery state available. 46028cbb9b1SJustin Hibbits */ 46128cbb9b1SJustin Hibbits static int 46228cbb9b1SJustin Hibbits handle_onfault(struct trapframe *frame) 46328cbb9b1SJustin Hibbits { 46428cbb9b1SJustin Hibbits struct thread *td; 465a18c313eSNathan Whitehorn jmp_buf *fb; 46628cbb9b1SJustin Hibbits 46728cbb9b1SJustin Hibbits td = curthread; 46828cbb9b1SJustin Hibbits fb = td->td_pcb->pcb_onfault; 46928cbb9b1SJustin Hibbits if (fb != NULL) { 470a18c313eSNathan Whitehorn frame->srr0 = (*fb)->_jb[FAULTBUF_LR]; 471a18c313eSNathan Whitehorn frame->fixreg[1] = (*fb)->_jb[FAULTBUF_R1]; 472a18c313eSNathan Whitehorn frame->fixreg[2] = (*fb)->_jb[FAULTBUF_R2]; 47328cbb9b1SJustin Hibbits frame->fixreg[3] = 1; 474a18c313eSNathan Whitehorn frame->cr = (*fb)->_jb[FAULTBUF_CR]; 475a18c313eSNathan Whitehorn bcopy(&(*fb)->_jb[FAULTBUF_R14], &frame->fixreg[14], 476a18c313eSNathan Whitehorn 18 * sizeof(register_t)); 477a18c313eSNathan Whitehorn td->td_pcb->pcb_onfault = NULL; /* Returns twice, not thrice */ 47828cbb9b1SJustin Hibbits return (1); 47928cbb9b1SJustin Hibbits } 48028cbb9b1SJustin Hibbits return (0); 48128cbb9b1SJustin Hibbits } 48228cbb9b1SJustin Hibbits 48328cbb9b1SJustin Hibbits int 48428cbb9b1SJustin Hibbits cpu_fetch_syscall_args(struct thread *td, struct syscall_args *sa) 48528cbb9b1SJustin Hibbits { 48628cbb9b1SJustin Hibbits struct proc *p; 48728cbb9b1SJustin Hibbits struct trapframe *frame; 48828cbb9b1SJustin Hibbits caddr_t params; 48928cbb9b1SJustin Hibbits size_t argsz; 49028cbb9b1SJustin Hibbits int error, n, i; 49128cbb9b1SJustin Hibbits 49228cbb9b1SJustin Hibbits p = td->td_proc; 49328cbb9b1SJustin Hibbits frame = td->td_frame; 49428cbb9b1SJustin Hibbits 49528cbb9b1SJustin Hibbits sa->code = frame->fixreg[0]; 49628cbb9b1SJustin Hibbits params = (caddr_t)(frame->fixreg + FIRSTARG); 49728cbb9b1SJustin Hibbits n = NARGREG; 49828cbb9b1SJustin Hibbits 49928cbb9b1SJustin Hibbits if (sa->code == SYS_syscall) { 50028cbb9b1SJustin Hibbits /* 50128cbb9b1SJustin Hibbits * code is first argument, 50228cbb9b1SJustin Hibbits * followed by actual args. 50328cbb9b1SJustin Hibbits */ 50428cbb9b1SJustin Hibbits sa->code = *(register_t *) params; 50528cbb9b1SJustin Hibbits params += sizeof(register_t); 50628cbb9b1SJustin Hibbits n -= 1; 50728cbb9b1SJustin Hibbits } else if (sa->code == SYS___syscall) { 50828cbb9b1SJustin Hibbits /* 50928cbb9b1SJustin Hibbits * Like syscall, but code is a quad, 51028cbb9b1SJustin Hibbits * so as to maintain quad alignment 51128cbb9b1SJustin Hibbits * for the rest of the args. 51228cbb9b1SJustin Hibbits */ 51328cbb9b1SJustin Hibbits if (SV_PROC_FLAG(p, SV_ILP32)) { 51428cbb9b1SJustin Hibbits params += sizeof(register_t); 51528cbb9b1SJustin Hibbits sa->code = *(register_t *) params; 51628cbb9b1SJustin Hibbits params += sizeof(register_t); 51728cbb9b1SJustin Hibbits n -= 2; 51828cbb9b1SJustin Hibbits } else { 51928cbb9b1SJustin Hibbits sa->code = *(register_t *) params; 52028cbb9b1SJustin Hibbits params += sizeof(register_t); 52128cbb9b1SJustin Hibbits n -= 1; 52228cbb9b1SJustin Hibbits } 52328cbb9b1SJustin Hibbits } 52428cbb9b1SJustin Hibbits 52528cbb9b1SJustin Hibbits if (p->p_sysent->sv_mask) 52628cbb9b1SJustin Hibbits sa->code &= p->p_sysent->sv_mask; 52728cbb9b1SJustin Hibbits if (sa->code >= p->p_sysent->sv_size) 52828cbb9b1SJustin Hibbits sa->callp = &p->p_sysent->sv_table[0]; 52928cbb9b1SJustin Hibbits else 53028cbb9b1SJustin Hibbits sa->callp = &p->p_sysent->sv_table[sa->code]; 53128cbb9b1SJustin Hibbits 53228cbb9b1SJustin Hibbits sa->narg = sa->callp->sy_narg; 53328cbb9b1SJustin Hibbits 53428cbb9b1SJustin Hibbits if (SV_PROC_FLAG(p, SV_ILP32)) { 53528cbb9b1SJustin Hibbits argsz = sizeof(uint32_t); 53628cbb9b1SJustin Hibbits 53728cbb9b1SJustin Hibbits for (i = 0; i < n; i++) 53828cbb9b1SJustin Hibbits sa->args[i] = ((u_register_t *)(params))[i] & 53928cbb9b1SJustin Hibbits 0xffffffff; 54028cbb9b1SJustin Hibbits } else { 54128cbb9b1SJustin Hibbits argsz = sizeof(uint64_t); 54228cbb9b1SJustin Hibbits 54328cbb9b1SJustin Hibbits for (i = 0; i < n; i++) 54428cbb9b1SJustin Hibbits sa->args[i] = ((u_register_t *)(params))[i]; 54528cbb9b1SJustin Hibbits } 54628cbb9b1SJustin Hibbits 54728cbb9b1SJustin Hibbits if (sa->narg > n) 54828cbb9b1SJustin Hibbits error = copyin(MOREARGS(frame->fixreg[1]), sa->args + n, 54928cbb9b1SJustin Hibbits (sa->narg - n) * argsz); 55028cbb9b1SJustin Hibbits else 55128cbb9b1SJustin Hibbits error = 0; 55228cbb9b1SJustin Hibbits 55328cbb9b1SJustin Hibbits #ifdef __powerpc64__ 55428cbb9b1SJustin Hibbits if (SV_PROC_FLAG(p, SV_ILP32) && sa->narg > n) { 55528cbb9b1SJustin Hibbits /* Expand the size of arguments copied from the stack */ 55628cbb9b1SJustin Hibbits 55728cbb9b1SJustin Hibbits for (i = sa->narg; i >= n; i--) 55828cbb9b1SJustin Hibbits sa->args[i] = ((uint32_t *)(&sa->args[n]))[i-n]; 55928cbb9b1SJustin Hibbits } 56028cbb9b1SJustin Hibbits #endif 56128cbb9b1SJustin Hibbits 56228cbb9b1SJustin Hibbits if (error == 0) { 56328cbb9b1SJustin Hibbits td->td_retval[0] = 0; 56428cbb9b1SJustin Hibbits td->td_retval[1] = frame->fixreg[FIRSTARG + 1]; 56528cbb9b1SJustin Hibbits } 56628cbb9b1SJustin Hibbits return (error); 56728cbb9b1SJustin Hibbits } 56828cbb9b1SJustin Hibbits 56928cbb9b1SJustin Hibbits #include "../../kern/subr_syscall.c" 57028cbb9b1SJustin Hibbits 57128cbb9b1SJustin Hibbits void 57228cbb9b1SJustin Hibbits syscall(struct trapframe *frame) 57328cbb9b1SJustin Hibbits { 57428cbb9b1SJustin Hibbits struct thread *td; 57528cbb9b1SJustin Hibbits struct syscall_args sa; 57628cbb9b1SJustin Hibbits int error; 57728cbb9b1SJustin Hibbits 57828cbb9b1SJustin Hibbits td = curthread; 57928cbb9b1SJustin Hibbits td->td_frame = frame; 58028cbb9b1SJustin Hibbits 58128cbb9b1SJustin Hibbits #ifdef __powerpc64__ 58228cbb9b1SJustin Hibbits /* 58328cbb9b1SJustin Hibbits * Speculatively restore last user SLB segment, which we know is 58428cbb9b1SJustin Hibbits * invalid already, since we are likely to do copyin()/copyout(). 58528cbb9b1SJustin Hibbits */ 58628cbb9b1SJustin Hibbits __asm __volatile ("slbmte %0, %1; isync" :: 58728cbb9b1SJustin Hibbits "r"(td->td_pcb->pcb_cpu.aim.usr_vsid), "r"(USER_SLB_SLBE)); 58828cbb9b1SJustin Hibbits #endif 58928cbb9b1SJustin Hibbits 59028cbb9b1SJustin Hibbits error = syscallenter(td, &sa); 59128cbb9b1SJustin Hibbits syscallret(td, error, &sa); 59228cbb9b1SJustin Hibbits } 59328cbb9b1SJustin Hibbits 59428cbb9b1SJustin Hibbits #ifdef __powerpc64__ 59528cbb9b1SJustin Hibbits /* Handle kernel SLB faults -- runs in real mode, all seat belts off */ 59628cbb9b1SJustin Hibbits void 59728cbb9b1SJustin Hibbits handle_kernel_slb_spill(int type, register_t dar, register_t srr0) 59828cbb9b1SJustin Hibbits { 59928cbb9b1SJustin Hibbits struct slb *slbcache; 60028cbb9b1SJustin Hibbits uint64_t slbe, slbv; 60128cbb9b1SJustin Hibbits uint64_t esid, addr; 60228cbb9b1SJustin Hibbits int i; 60328cbb9b1SJustin Hibbits 60428cbb9b1SJustin Hibbits addr = (type == EXC_ISE) ? srr0 : dar; 60528cbb9b1SJustin Hibbits slbcache = PCPU_GET(slb); 60628cbb9b1SJustin Hibbits esid = (uintptr_t)addr >> ADDR_SR_SHFT; 60728cbb9b1SJustin Hibbits slbe = (esid << SLBE_ESID_SHIFT) | SLBE_VALID; 60828cbb9b1SJustin Hibbits 60928cbb9b1SJustin Hibbits /* See if the hardware flushed this somehow (can happen in LPARs) */ 61028cbb9b1SJustin Hibbits for (i = 0; i < n_slbs; i++) 61128cbb9b1SJustin Hibbits if (slbcache[i].slbe == (slbe | (uint64_t)i)) 61228cbb9b1SJustin Hibbits return; 61328cbb9b1SJustin Hibbits 61428cbb9b1SJustin Hibbits /* Not in the map, needs to actually be added */ 61528cbb9b1SJustin Hibbits slbv = kernel_va_to_slbv(addr); 61628cbb9b1SJustin Hibbits if (slbcache[USER_SLB_SLOT].slbe == 0) { 61728cbb9b1SJustin Hibbits for (i = 0; i < n_slbs; i++) { 61828cbb9b1SJustin Hibbits if (i == USER_SLB_SLOT) 61928cbb9b1SJustin Hibbits continue; 62028cbb9b1SJustin Hibbits if (!(slbcache[i].slbe & SLBE_VALID)) 62128cbb9b1SJustin Hibbits goto fillkernslb; 62228cbb9b1SJustin Hibbits } 62328cbb9b1SJustin Hibbits 62428cbb9b1SJustin Hibbits if (i == n_slbs) 62528cbb9b1SJustin Hibbits slbcache[USER_SLB_SLOT].slbe = 1; 62628cbb9b1SJustin Hibbits } 62728cbb9b1SJustin Hibbits 62828cbb9b1SJustin Hibbits /* Sacrifice a random SLB entry that is not the user entry */ 62928cbb9b1SJustin Hibbits i = mftb() % n_slbs; 63028cbb9b1SJustin Hibbits if (i == USER_SLB_SLOT) 63128cbb9b1SJustin Hibbits i = (i+1) % n_slbs; 63228cbb9b1SJustin Hibbits 63328cbb9b1SJustin Hibbits fillkernslb: 63428cbb9b1SJustin Hibbits /* Write new entry */ 63528cbb9b1SJustin Hibbits slbcache[i].slbv = slbv; 63628cbb9b1SJustin Hibbits slbcache[i].slbe = slbe | (uint64_t)i; 63728cbb9b1SJustin Hibbits 63828cbb9b1SJustin Hibbits /* Trap handler will restore from cache on exit */ 63928cbb9b1SJustin Hibbits } 64028cbb9b1SJustin Hibbits 64128cbb9b1SJustin Hibbits static int 64228cbb9b1SJustin Hibbits handle_user_slb_spill(pmap_t pm, vm_offset_t addr) 64328cbb9b1SJustin Hibbits { 64428cbb9b1SJustin Hibbits struct slb *user_entry; 64528cbb9b1SJustin Hibbits uint64_t esid; 64628cbb9b1SJustin Hibbits int i; 64728cbb9b1SJustin Hibbits 64828cbb9b1SJustin Hibbits esid = (uintptr_t)addr >> ADDR_SR_SHFT; 64928cbb9b1SJustin Hibbits 65028cbb9b1SJustin Hibbits PMAP_LOCK(pm); 65128cbb9b1SJustin Hibbits user_entry = user_va_to_slb_entry(pm, addr); 65228cbb9b1SJustin Hibbits 65328cbb9b1SJustin Hibbits if (user_entry == NULL) { 65428cbb9b1SJustin Hibbits /* allocate_vsid auto-spills it */ 65528cbb9b1SJustin Hibbits (void)allocate_user_vsid(pm, esid, 0); 65628cbb9b1SJustin Hibbits } else { 65728cbb9b1SJustin Hibbits /* 65828cbb9b1SJustin Hibbits * Check that another CPU has not already mapped this. 65928cbb9b1SJustin Hibbits * XXX: Per-thread SLB caches would be better. 66028cbb9b1SJustin Hibbits */ 66128cbb9b1SJustin Hibbits for (i = 0; i < pm->pm_slb_len; i++) 66228cbb9b1SJustin Hibbits if (pm->pm_slb[i] == user_entry) 66328cbb9b1SJustin Hibbits break; 66428cbb9b1SJustin Hibbits 66528cbb9b1SJustin Hibbits if (i == pm->pm_slb_len) 66628cbb9b1SJustin Hibbits slb_insert_user(pm, user_entry); 66728cbb9b1SJustin Hibbits } 66828cbb9b1SJustin Hibbits PMAP_UNLOCK(pm); 66928cbb9b1SJustin Hibbits 67028cbb9b1SJustin Hibbits return (0); 67128cbb9b1SJustin Hibbits } 67228cbb9b1SJustin Hibbits #endif 67328cbb9b1SJustin Hibbits 67428cbb9b1SJustin Hibbits static int 67528cbb9b1SJustin Hibbits trap_pfault(struct trapframe *frame, int user) 67628cbb9b1SJustin Hibbits { 67728cbb9b1SJustin Hibbits vm_offset_t eva, va; 67828cbb9b1SJustin Hibbits struct thread *td; 67928cbb9b1SJustin Hibbits struct proc *p; 68028cbb9b1SJustin Hibbits vm_map_t map; 68128cbb9b1SJustin Hibbits vm_prot_t ftype; 68228cbb9b1SJustin Hibbits int rv; 68328cbb9b1SJustin Hibbits #ifdef AIM 68428cbb9b1SJustin Hibbits register_t user_sr; 68528cbb9b1SJustin Hibbits #endif 68628cbb9b1SJustin Hibbits 68728cbb9b1SJustin Hibbits td = curthread; 68828cbb9b1SJustin Hibbits p = td->td_proc; 68928cbb9b1SJustin Hibbits if (frame->exc == EXC_ISI) { 69028cbb9b1SJustin Hibbits eva = frame->srr0; 69128cbb9b1SJustin Hibbits ftype = VM_PROT_EXECUTE; 69228cbb9b1SJustin Hibbits if (frame->srr1 & SRR1_ISI_PFAULT) 69328cbb9b1SJustin Hibbits ftype |= VM_PROT_READ; 69428cbb9b1SJustin Hibbits } else { 69528cbb9b1SJustin Hibbits eva = frame->dar; 69628cbb9b1SJustin Hibbits #ifdef BOOKE 69728cbb9b1SJustin Hibbits if (frame->cpu.booke.esr & ESR_ST) 69828cbb9b1SJustin Hibbits #else 69928cbb9b1SJustin Hibbits if (frame->cpu.aim.dsisr & DSISR_STORE) 70028cbb9b1SJustin Hibbits #endif 70128cbb9b1SJustin Hibbits ftype = VM_PROT_WRITE; 70228cbb9b1SJustin Hibbits else 70328cbb9b1SJustin Hibbits ftype = VM_PROT_READ; 70428cbb9b1SJustin Hibbits } 70528cbb9b1SJustin Hibbits 70628cbb9b1SJustin Hibbits if (user) { 70728cbb9b1SJustin Hibbits KASSERT(p->p_vmspace != NULL, ("trap_pfault: vmspace NULL")); 70828cbb9b1SJustin Hibbits map = &p->p_vmspace->vm_map; 70928cbb9b1SJustin Hibbits } else { 71028cbb9b1SJustin Hibbits #ifdef BOOKE 71128cbb9b1SJustin Hibbits if (eva < VM_MAXUSER_ADDRESS) { 71228cbb9b1SJustin Hibbits #else 71328cbb9b1SJustin Hibbits if ((eva >> ADDR_SR_SHFT) == (USER_ADDR >> ADDR_SR_SHFT)) { 71428cbb9b1SJustin Hibbits #endif 71528cbb9b1SJustin Hibbits map = &p->p_vmspace->vm_map; 71628cbb9b1SJustin Hibbits 71728cbb9b1SJustin Hibbits #ifdef AIM 71828cbb9b1SJustin Hibbits user_sr = td->td_pcb->pcb_cpu.aim.usr_segm; 71928cbb9b1SJustin Hibbits eva &= ADDR_PIDX | ADDR_POFF; 72028cbb9b1SJustin Hibbits eva |= user_sr << ADDR_SR_SHFT; 72128cbb9b1SJustin Hibbits #endif 72228cbb9b1SJustin Hibbits } else { 72328cbb9b1SJustin Hibbits map = kernel_map; 72428cbb9b1SJustin Hibbits } 72528cbb9b1SJustin Hibbits } 72628cbb9b1SJustin Hibbits va = trunc_page(eva); 72728cbb9b1SJustin Hibbits 7281fa67124SKonstantin Belousov /* Fault in the page. */ 72928cbb9b1SJustin Hibbits rv = vm_fault(map, va, ftype, VM_FAULT_NORMAL); 73028cbb9b1SJustin Hibbits /* 73128cbb9b1SJustin Hibbits * XXXDTRACE: add dtrace_doubletrap_func here? 73228cbb9b1SJustin Hibbits */ 73328cbb9b1SJustin Hibbits 73428cbb9b1SJustin Hibbits if (rv == KERN_SUCCESS) 73528cbb9b1SJustin Hibbits return (0); 73628cbb9b1SJustin Hibbits 73728cbb9b1SJustin Hibbits if (!user && handle_onfault(frame)) 73828cbb9b1SJustin Hibbits return (0); 73928cbb9b1SJustin Hibbits 74028cbb9b1SJustin Hibbits return (SIGSEGV); 74128cbb9b1SJustin Hibbits } 74228cbb9b1SJustin Hibbits 74328cbb9b1SJustin Hibbits /* 74428cbb9b1SJustin Hibbits * For now, this only deals with the particular unaligned access case 74528cbb9b1SJustin Hibbits * that gcc tends to generate. Eventually it should handle all of the 74628cbb9b1SJustin Hibbits * possibilities that can happen on a 32-bit PowerPC in big-endian mode. 74728cbb9b1SJustin Hibbits */ 74828cbb9b1SJustin Hibbits 74928cbb9b1SJustin Hibbits static int 75028cbb9b1SJustin Hibbits fix_unaligned(struct thread *td, struct trapframe *frame) 75128cbb9b1SJustin Hibbits { 75228cbb9b1SJustin Hibbits struct thread *fputhread; 753dc9b124dSJustin Hibbits #ifdef __SPE__ 754dc9b124dSJustin Hibbits uint32_t inst; 755dc9b124dSJustin Hibbits #endif 75628cbb9b1SJustin Hibbits int indicator, reg; 75728cbb9b1SJustin Hibbits double *fpr; 75828cbb9b1SJustin Hibbits 759dc9b124dSJustin Hibbits #ifdef __SPE__ 760dc9b124dSJustin Hibbits indicator = (frame->cpu.booke.esr & (ESR_ST|ESR_SPE)); 761dc9b124dSJustin Hibbits if (indicator & ESR_SPE) { 762dc9b124dSJustin Hibbits if (copyin((void *)frame->srr0, &inst, sizeof(inst)) != 0) 763dc9b124dSJustin Hibbits return (-1); 764dc9b124dSJustin Hibbits reg = EXC_ALI_SPE_REG(inst); 765dc9b124dSJustin Hibbits fpr = (double *)td->td_pcb->pcb_vec.vr[reg]; 766dc9b124dSJustin Hibbits fputhread = PCPU_GET(vecthread); 767dc9b124dSJustin Hibbits 76889965e70SJustin Hibbits /* Juggle the SPE to ensure that we've initialized 76989965e70SJustin Hibbits * the registers, and that their current state is in 770dc9b124dSJustin Hibbits * the PCB. 771dc9b124dSJustin Hibbits */ 772eaa5e396SJustin Hibbits if (fputhread != td) { 773eaa5e396SJustin Hibbits if (fputhread) 774eaa5e396SJustin Hibbits save_vec(fputhread); 775dc9b124dSJustin Hibbits enable_vec(td); 776dc9b124dSJustin Hibbits } 777dc9b124dSJustin Hibbits save_vec(td); 778dc9b124dSJustin Hibbits 779dc9b124dSJustin Hibbits if (!(indicator & ESR_ST)) { 780dc9b124dSJustin Hibbits if (copyin((void *)frame->dar, fpr, 781dc9b124dSJustin Hibbits sizeof(double)) != 0) 782dc9b124dSJustin Hibbits return (-1); 783dc9b124dSJustin Hibbits frame->fixreg[reg] = td->td_pcb->pcb_vec.vr[reg][1]; 784dc9b124dSJustin Hibbits enable_vec(td); 785dc9b124dSJustin Hibbits } else { 786dc9b124dSJustin Hibbits td->td_pcb->pcb_vec.vr[reg][1] = frame->fixreg[reg]; 787dc9b124dSJustin Hibbits if (copyout(fpr, (void *)frame->dar, 788dc9b124dSJustin Hibbits sizeof(double)) != 0) 789dc9b124dSJustin Hibbits return (-1); 790dc9b124dSJustin Hibbits } 791dc9b124dSJustin Hibbits return (0); 792dc9b124dSJustin Hibbits } 793dc9b124dSJustin Hibbits #else 79428cbb9b1SJustin Hibbits indicator = EXC_ALI_OPCODE_INDICATOR(frame->cpu.aim.dsisr); 79528cbb9b1SJustin Hibbits 79628cbb9b1SJustin Hibbits switch (indicator) { 79728cbb9b1SJustin Hibbits case EXC_ALI_LFD: 79828cbb9b1SJustin Hibbits case EXC_ALI_STFD: 79928cbb9b1SJustin Hibbits reg = EXC_ALI_RST(frame->cpu.aim.dsisr); 80028cbb9b1SJustin Hibbits fpr = &td->td_pcb->pcb_fpu.fpr[reg].fpr; 80128cbb9b1SJustin Hibbits fputhread = PCPU_GET(fputhread); 80228cbb9b1SJustin Hibbits 80328cbb9b1SJustin Hibbits /* Juggle the FPU to ensure that we've initialized 80428cbb9b1SJustin Hibbits * the FPRs, and that their current state is in 80528cbb9b1SJustin Hibbits * the PCB. 80628cbb9b1SJustin Hibbits */ 80728cbb9b1SJustin Hibbits if (fputhread != td) { 80828cbb9b1SJustin Hibbits if (fputhread) 80928cbb9b1SJustin Hibbits save_fpu(fputhread); 81028cbb9b1SJustin Hibbits enable_fpu(td); 81128cbb9b1SJustin Hibbits } 81228cbb9b1SJustin Hibbits save_fpu(td); 81328cbb9b1SJustin Hibbits 81428cbb9b1SJustin Hibbits if (indicator == EXC_ALI_LFD) { 81528cbb9b1SJustin Hibbits if (copyin((void *)frame->dar, fpr, 81628cbb9b1SJustin Hibbits sizeof(double)) != 0) 81728cbb9b1SJustin Hibbits return (-1); 81828cbb9b1SJustin Hibbits enable_fpu(td); 81928cbb9b1SJustin Hibbits } else { 82028cbb9b1SJustin Hibbits if (copyout(fpr, (void *)frame->dar, 82128cbb9b1SJustin Hibbits sizeof(double)) != 0) 82228cbb9b1SJustin Hibbits return (-1); 82328cbb9b1SJustin Hibbits } 82428cbb9b1SJustin Hibbits return (0); 82528cbb9b1SJustin Hibbits break; 82628cbb9b1SJustin Hibbits } 827dc9b124dSJustin Hibbits #endif 82828cbb9b1SJustin Hibbits 82928cbb9b1SJustin Hibbits return (-1); 83028cbb9b1SJustin Hibbits } 83128cbb9b1SJustin Hibbits 83228cbb9b1SJustin Hibbits #ifdef KDB 83328cbb9b1SJustin Hibbits int db_trap_glue(struct trapframe *); /* Called from trap_subr.S */ 83428cbb9b1SJustin Hibbits 83528cbb9b1SJustin Hibbits int 83628cbb9b1SJustin Hibbits db_trap_glue(struct trapframe *frame) 83728cbb9b1SJustin Hibbits { 83828cbb9b1SJustin Hibbits if (!(frame->srr1 & PSL_PR) 83928cbb9b1SJustin Hibbits && (frame->exc == EXC_TRC || frame->exc == EXC_RUNMODETRC 840e3e38bc7SJustin Hibbits #ifdef AIM 84128cbb9b1SJustin Hibbits || (frame->exc == EXC_PGM 8427a67c1f8SJustin Hibbits && (frame->srr1 & EXC_PGM_TRAP)) 843e3e38bc7SJustin Hibbits #else 844e3e38bc7SJustin Hibbits || (frame->exc == EXC_DEBUG) 845e3e38bc7SJustin Hibbits #endif 84628cbb9b1SJustin Hibbits || frame->exc == EXC_BPT 84728cbb9b1SJustin Hibbits || frame->exc == EXC_DSI)) { 84828cbb9b1SJustin Hibbits int type = frame->exc; 84928cbb9b1SJustin Hibbits 85028cbb9b1SJustin Hibbits /* Ignore DTrace traps. */ 85128cbb9b1SJustin Hibbits if (*(uint32_t *)frame->srr0 == EXC_DTRACE) 85228cbb9b1SJustin Hibbits return (0); 853e3e38bc7SJustin Hibbits #ifdef AIM 8547a67c1f8SJustin Hibbits if (type == EXC_PGM && (frame->srr1 & EXC_PGM_TRAP)) { 855e3e38bc7SJustin Hibbits #else 856e3e38bc7SJustin Hibbits if (frame->cpu.booke.esr & ESR_PTR) { 857e3e38bc7SJustin Hibbits #endif 85828cbb9b1SJustin Hibbits type = T_BREAKPOINT; 85928cbb9b1SJustin Hibbits } 86028cbb9b1SJustin Hibbits return (kdb_trap(type, 0, frame)); 86128cbb9b1SJustin Hibbits } 86228cbb9b1SJustin Hibbits 86328cbb9b1SJustin Hibbits return (0); 86428cbb9b1SJustin Hibbits } 86528cbb9b1SJustin Hibbits #endif 866