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/pmap.h> 7228cbb9b1SJustin Hibbits #include <machine/psl.h> 7328cbb9b1SJustin Hibbits #include <machine/trap.h> 7428cbb9b1SJustin Hibbits #include <machine/spr.h> 7528cbb9b1SJustin Hibbits #include <machine/sr.h> 7628cbb9b1SJustin Hibbits 77a18c313eSNathan Whitehorn /* Below matches setjmp.S */ 78a18c313eSNathan Whitehorn #define FAULTBUF_LR 21 7928cbb9b1SJustin Hibbits #define FAULTBUF_R1 1 8028cbb9b1SJustin Hibbits #define FAULTBUF_R2 2 81a18c313eSNathan Whitehorn #define FAULTBUF_CR 22 82a18c313eSNathan Whitehorn #define FAULTBUF_R14 3 8328cbb9b1SJustin Hibbits 8428cbb9b1SJustin Hibbits static void trap_fatal(struct trapframe *frame); 8528cbb9b1SJustin Hibbits static void printtrap(u_int vector, struct trapframe *frame, int isfatal, 8628cbb9b1SJustin Hibbits int user); 8728cbb9b1SJustin Hibbits static int trap_pfault(struct trapframe *frame, int user); 8828cbb9b1SJustin Hibbits static int fix_unaligned(struct thread *td, struct trapframe *frame); 8928cbb9b1SJustin Hibbits static int handle_onfault(struct trapframe *frame); 9028cbb9b1SJustin Hibbits static void syscall(struct trapframe *frame); 9128cbb9b1SJustin Hibbits 9228cbb9b1SJustin Hibbits #ifdef __powerpc64__ 9328cbb9b1SJustin Hibbits void handle_kernel_slb_spill(int, register_t, register_t); 9428cbb9b1SJustin Hibbits static int handle_user_slb_spill(pmap_t pm, vm_offset_t addr); 9528cbb9b1SJustin Hibbits extern int n_slbs; 9628cbb9b1SJustin Hibbits #endif 9728cbb9b1SJustin Hibbits 9828cbb9b1SJustin Hibbits struct powerpc_exception { 9928cbb9b1SJustin Hibbits u_int vector; 10028cbb9b1SJustin Hibbits char *name; 10128cbb9b1SJustin Hibbits }; 10228cbb9b1SJustin Hibbits 10328cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS 10428cbb9b1SJustin Hibbits #include <sys/dtrace_bsd.h> 10528cbb9b1SJustin Hibbits 10628cbb9b1SJustin Hibbits int (*dtrace_invop_jump_addr)(struct trapframe *); 10728cbb9b1SJustin Hibbits #endif 10828cbb9b1SJustin Hibbits 10928cbb9b1SJustin Hibbits static struct powerpc_exception powerpc_exceptions[] = { 11028cbb9b1SJustin Hibbits { EXC_CRIT, "critical input" }, 11128cbb9b1SJustin Hibbits { EXC_RST, "system reset" }, 11228cbb9b1SJustin Hibbits { EXC_MCHK, "machine check" }, 11328cbb9b1SJustin Hibbits { EXC_DSI, "data storage interrupt" }, 11428cbb9b1SJustin Hibbits { EXC_DSE, "data segment exception" }, 11528cbb9b1SJustin Hibbits { EXC_ISI, "instruction storage interrupt" }, 11628cbb9b1SJustin Hibbits { EXC_ISE, "instruction segment exception" }, 11728cbb9b1SJustin Hibbits { EXC_EXI, "external interrupt" }, 11828cbb9b1SJustin Hibbits { EXC_ALI, "alignment" }, 11928cbb9b1SJustin Hibbits { EXC_PGM, "program" }, 12028cbb9b1SJustin Hibbits { EXC_FPU, "floating-point unavailable" }, 12128cbb9b1SJustin Hibbits { EXC_APU, "auxiliary proc unavailable" }, 12228cbb9b1SJustin Hibbits { EXC_DECR, "decrementer" }, 12328cbb9b1SJustin Hibbits { EXC_FIT, "fixed-interval timer" }, 12428cbb9b1SJustin Hibbits { EXC_WDOG, "watchdog timer" }, 12528cbb9b1SJustin Hibbits { EXC_SC, "system call" }, 12628cbb9b1SJustin Hibbits { EXC_TRC, "trace" }, 12728cbb9b1SJustin Hibbits { EXC_FPA, "floating-point assist" }, 12828cbb9b1SJustin Hibbits { EXC_DEBUG, "debug" }, 12928cbb9b1SJustin Hibbits { EXC_PERF, "performance monitoring" }, 13028cbb9b1SJustin Hibbits { EXC_VEC, "altivec unavailable" }, 13128cbb9b1SJustin Hibbits { EXC_VSX, "vsx unavailable" }, 13228cbb9b1SJustin Hibbits { EXC_ITMISS, "instruction tlb miss" }, 13328cbb9b1SJustin Hibbits { EXC_DLMISS, "data load tlb miss" }, 13428cbb9b1SJustin Hibbits { EXC_DSMISS, "data store tlb miss" }, 13528cbb9b1SJustin Hibbits { EXC_BPT, "instruction breakpoint" }, 13628cbb9b1SJustin Hibbits { EXC_SMI, "system management" }, 13728cbb9b1SJustin Hibbits { EXC_VECAST_G4, "altivec assist" }, 13828cbb9b1SJustin Hibbits { EXC_THRM, "thermal management" }, 13928cbb9b1SJustin Hibbits { EXC_RUNMODETRC, "run mode/trace" }, 14028cbb9b1SJustin Hibbits { EXC_LAST, NULL } 14128cbb9b1SJustin Hibbits }; 14228cbb9b1SJustin Hibbits 14328cbb9b1SJustin Hibbits static const char * 14428cbb9b1SJustin Hibbits trapname(u_int vector) 14528cbb9b1SJustin Hibbits { 14628cbb9b1SJustin Hibbits struct powerpc_exception *pe; 14728cbb9b1SJustin Hibbits 14828cbb9b1SJustin Hibbits for (pe = powerpc_exceptions; pe->vector != EXC_LAST; pe++) { 14928cbb9b1SJustin Hibbits if (pe->vector == vector) 15028cbb9b1SJustin Hibbits return (pe->name); 15128cbb9b1SJustin Hibbits } 15228cbb9b1SJustin Hibbits 15328cbb9b1SJustin Hibbits return ("unknown"); 15428cbb9b1SJustin Hibbits } 15528cbb9b1SJustin Hibbits 15628cbb9b1SJustin Hibbits void 15728cbb9b1SJustin Hibbits trap(struct trapframe *frame) 15828cbb9b1SJustin Hibbits { 15928cbb9b1SJustin Hibbits struct thread *td; 16028cbb9b1SJustin Hibbits struct proc *p; 16128cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS 16228cbb9b1SJustin Hibbits uint32_t inst; 16328cbb9b1SJustin Hibbits #endif 16428cbb9b1SJustin Hibbits int sig, type, user; 16528cbb9b1SJustin Hibbits u_int ucode; 16628cbb9b1SJustin Hibbits ksiginfo_t ksi; 16728cbb9b1SJustin Hibbits 16828cbb9b1SJustin Hibbits PCPU_INC(cnt.v_trap); 16928cbb9b1SJustin Hibbits 17028cbb9b1SJustin Hibbits td = curthread; 17128cbb9b1SJustin Hibbits p = td->td_proc; 17228cbb9b1SJustin Hibbits 17328cbb9b1SJustin Hibbits type = ucode = frame->exc; 17428cbb9b1SJustin Hibbits sig = 0; 17528cbb9b1SJustin Hibbits user = frame->srr1 & PSL_PR; 17628cbb9b1SJustin Hibbits 17728cbb9b1SJustin Hibbits CTR3(KTR_TRAP, "trap: %s type=%s (%s)", td->td_name, 17828cbb9b1SJustin Hibbits trapname(type), user ? "user" : "kernel"); 17928cbb9b1SJustin Hibbits 18028cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS 18128cbb9b1SJustin Hibbits /* 18228cbb9b1SJustin Hibbits * A trap can occur while DTrace executes a probe. Before 18328cbb9b1SJustin Hibbits * executing the probe, DTrace blocks re-scheduling and sets 18428cbb9b1SJustin Hibbits * a flag in its per-cpu flags to indicate that it doesn't 18528cbb9b1SJustin Hibbits * want to fault. On returning from the probe, the no-fault 18628cbb9b1SJustin Hibbits * flag is cleared and finally re-scheduling is enabled. 18728cbb9b1SJustin Hibbits * 18828cbb9b1SJustin Hibbits * If the DTrace kernel module has registered a trap handler, 18928cbb9b1SJustin Hibbits * call it and if it returns non-zero, assume that it has 19028cbb9b1SJustin Hibbits * handled the trap and modified the trap frame so that this 19128cbb9b1SJustin Hibbits * function can return normally. 19228cbb9b1SJustin Hibbits */ 19328cbb9b1SJustin Hibbits if (dtrace_trap_func != NULL && (*dtrace_trap_func)(frame, type) != 0) 19428cbb9b1SJustin Hibbits return; 19528cbb9b1SJustin Hibbits #endif 19628cbb9b1SJustin Hibbits 19728cbb9b1SJustin Hibbits if (user) { 19828cbb9b1SJustin Hibbits td->td_pticks = 0; 19928cbb9b1SJustin Hibbits td->td_frame = frame; 2004ea6a9a2SMateusz Guzik if (td->td_cowgen != p->p_cowgen) 2014ea6a9a2SMateusz Guzik thread_cow_update(td); 20228cbb9b1SJustin Hibbits 20328cbb9b1SJustin Hibbits /* User Mode Traps */ 20428cbb9b1SJustin Hibbits switch (type) { 20528cbb9b1SJustin Hibbits case EXC_RUNMODETRC: 20628cbb9b1SJustin Hibbits case EXC_TRC: 20728cbb9b1SJustin Hibbits frame->srr1 &= ~PSL_SE; 20828cbb9b1SJustin Hibbits sig = SIGTRAP; 20928cbb9b1SJustin Hibbits ucode = TRAP_TRACE; 21028cbb9b1SJustin Hibbits break; 21128cbb9b1SJustin Hibbits 21228cbb9b1SJustin Hibbits #ifdef __powerpc64__ 21328cbb9b1SJustin Hibbits case EXC_ISE: 21428cbb9b1SJustin Hibbits case EXC_DSE: 21528cbb9b1SJustin Hibbits if (handle_user_slb_spill(&p->p_vmspace->vm_pmap, 21628cbb9b1SJustin Hibbits (type == EXC_ISE) ? frame->srr0 : frame->dar) != 0){ 21728cbb9b1SJustin Hibbits sig = SIGSEGV; 21828cbb9b1SJustin Hibbits ucode = SEGV_MAPERR; 21928cbb9b1SJustin Hibbits } 22028cbb9b1SJustin Hibbits break; 22128cbb9b1SJustin Hibbits #endif 22228cbb9b1SJustin Hibbits case EXC_DSI: 22328cbb9b1SJustin Hibbits case EXC_ISI: 22428cbb9b1SJustin Hibbits sig = trap_pfault(frame, 1); 22528cbb9b1SJustin Hibbits if (sig == SIGSEGV) 22628cbb9b1SJustin Hibbits ucode = SEGV_MAPERR; 22728cbb9b1SJustin Hibbits break; 22828cbb9b1SJustin Hibbits 22928cbb9b1SJustin Hibbits case EXC_SC: 23028cbb9b1SJustin Hibbits syscall(frame); 23128cbb9b1SJustin Hibbits break; 23228cbb9b1SJustin Hibbits 23328cbb9b1SJustin Hibbits case EXC_FPU: 23428cbb9b1SJustin Hibbits KASSERT((td->td_pcb->pcb_flags & PCB_FPU) != PCB_FPU, 23528cbb9b1SJustin Hibbits ("FPU already enabled for thread")); 23628cbb9b1SJustin Hibbits enable_fpu(td); 23728cbb9b1SJustin Hibbits break; 23828cbb9b1SJustin Hibbits 23928cbb9b1SJustin Hibbits case EXC_VEC: 24028cbb9b1SJustin Hibbits KASSERT((td->td_pcb->pcb_flags & PCB_VEC) != PCB_VEC, 24128cbb9b1SJustin Hibbits ("Altivec already enabled for thread")); 24228cbb9b1SJustin Hibbits enable_vec(td); 24328cbb9b1SJustin Hibbits break; 24428cbb9b1SJustin Hibbits 24528cbb9b1SJustin Hibbits case EXC_VSX: 24628cbb9b1SJustin Hibbits KASSERT((td->td_pcb->pcb_flags & PCB_VSX) != PCB_VSX, 24728cbb9b1SJustin Hibbits ("VSX already enabled for thread")); 24828cbb9b1SJustin Hibbits if (!(td->td_pcb->pcb_flags & PCB_VEC)) 24928cbb9b1SJustin Hibbits enable_vec(td); 25028cbb9b1SJustin Hibbits if (!(td->td_pcb->pcb_flags & PCB_FPU)) 25128cbb9b1SJustin Hibbits save_fpu(td); 25228cbb9b1SJustin Hibbits td->td_pcb->pcb_flags |= PCB_VSX; 25328cbb9b1SJustin Hibbits enable_fpu(td); 25428cbb9b1SJustin Hibbits break; 25528cbb9b1SJustin Hibbits 256541c5806SJustin Hibbits case EXC_VECAST_E: 25728cbb9b1SJustin Hibbits case EXC_VECAST_G4: 25828cbb9b1SJustin Hibbits case EXC_VECAST_G5: 25928cbb9b1SJustin Hibbits /* 26028cbb9b1SJustin Hibbits * We get a VPU assist exception for IEEE mode 26128cbb9b1SJustin Hibbits * vector operations on denormalized floats. 26228cbb9b1SJustin Hibbits * Emulating this is a giant pain, so for now, 26328cbb9b1SJustin Hibbits * just switch off IEEE mode and treat them as 26428cbb9b1SJustin Hibbits * zero. 26528cbb9b1SJustin Hibbits */ 26628cbb9b1SJustin Hibbits 26728cbb9b1SJustin Hibbits save_vec(td); 26828cbb9b1SJustin Hibbits td->td_pcb->pcb_vec.vscr |= ALTIVEC_VSCR_NJ; 26928cbb9b1SJustin Hibbits enable_vec(td); 27028cbb9b1SJustin Hibbits break; 27128cbb9b1SJustin Hibbits 27228cbb9b1SJustin Hibbits case EXC_ALI: 27328cbb9b1SJustin Hibbits if (fix_unaligned(td, frame) != 0) { 27428cbb9b1SJustin Hibbits sig = SIGBUS; 27528cbb9b1SJustin Hibbits ucode = BUS_ADRALN; 27628cbb9b1SJustin Hibbits } 27728cbb9b1SJustin Hibbits else 27828cbb9b1SJustin Hibbits frame->srr0 += 4; 27928cbb9b1SJustin Hibbits break; 28028cbb9b1SJustin Hibbits 28128cbb9b1SJustin Hibbits case EXC_DEBUG: /* Single stepping */ 28228cbb9b1SJustin Hibbits mtspr(SPR_DBSR, mfspr(SPR_DBSR)); 28328cbb9b1SJustin Hibbits frame->srr1 &= ~PSL_DE; 28428cbb9b1SJustin Hibbits frame->cpu.booke.dbcr0 &= ~(DBCR0_IDM || DBCR0_IC); 28528cbb9b1SJustin Hibbits sig = SIGTRAP; 28628cbb9b1SJustin Hibbits ucode = TRAP_TRACE; 28728cbb9b1SJustin Hibbits break; 28828cbb9b1SJustin Hibbits 28928cbb9b1SJustin Hibbits case EXC_PGM: 29028cbb9b1SJustin Hibbits /* Identify the trap reason */ 29128cbb9b1SJustin Hibbits #ifdef AIM 29228cbb9b1SJustin Hibbits if (frame->srr1 & EXC_PGM_TRAP) { 29328cbb9b1SJustin Hibbits #else 29428cbb9b1SJustin Hibbits if (frame->cpu.booke.esr & ESR_PTR) { 29528cbb9b1SJustin Hibbits #endif 29628cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS 29728cbb9b1SJustin Hibbits inst = fuword32((const void *)frame->srr0); 29828cbb9b1SJustin Hibbits if (inst == 0x0FFFDDDD && 29928cbb9b1SJustin Hibbits dtrace_pid_probe_ptr != NULL) { 30028cbb9b1SJustin Hibbits struct reg regs; 30128cbb9b1SJustin Hibbits fill_regs(td, ®s); 30228cbb9b1SJustin Hibbits (*dtrace_pid_probe_ptr)(®s); 30328cbb9b1SJustin Hibbits break; 30428cbb9b1SJustin Hibbits } 30528cbb9b1SJustin Hibbits #endif 30628cbb9b1SJustin Hibbits sig = SIGTRAP; 30728cbb9b1SJustin Hibbits ucode = TRAP_BRKPT; 30828cbb9b1SJustin Hibbits } else { 30928cbb9b1SJustin Hibbits sig = ppc_instr_emulate(frame, td->td_pcb); 31028cbb9b1SJustin Hibbits if (sig == SIGILL) { 31128cbb9b1SJustin Hibbits if (frame->srr1 & EXC_PGM_PRIV) 31228cbb9b1SJustin Hibbits ucode = ILL_PRVOPC; 31328cbb9b1SJustin Hibbits else if (frame->srr1 & EXC_PGM_ILLEGAL) 31428cbb9b1SJustin Hibbits ucode = ILL_ILLOPC; 31528cbb9b1SJustin Hibbits } else if (sig == SIGFPE) 31628cbb9b1SJustin Hibbits ucode = FPE_FLTINV; /* Punt for now, invalid operation. */ 31728cbb9b1SJustin Hibbits } 31828cbb9b1SJustin Hibbits break; 31928cbb9b1SJustin Hibbits 32028cbb9b1SJustin Hibbits case EXC_MCHK: 32128cbb9b1SJustin Hibbits /* 32228cbb9b1SJustin Hibbits * Note that this may not be recoverable for the user 32328cbb9b1SJustin Hibbits * process, depending on the type of machine check, 32428cbb9b1SJustin Hibbits * but it at least prevents the kernel from dying. 32528cbb9b1SJustin Hibbits */ 32628cbb9b1SJustin Hibbits sig = SIGBUS; 32728cbb9b1SJustin Hibbits ucode = BUS_OBJERR; 32828cbb9b1SJustin Hibbits break; 32928cbb9b1SJustin Hibbits 33028cbb9b1SJustin Hibbits default: 33128cbb9b1SJustin Hibbits trap_fatal(frame); 33228cbb9b1SJustin Hibbits } 33328cbb9b1SJustin Hibbits } else { 33428cbb9b1SJustin Hibbits /* Kernel Mode Traps */ 33528cbb9b1SJustin Hibbits 33628cbb9b1SJustin Hibbits KASSERT(cold || td->td_ucred != NULL, 33728cbb9b1SJustin Hibbits ("kernel trap doesn't have ucred")); 33828cbb9b1SJustin Hibbits switch (type) { 33928cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS 34028cbb9b1SJustin Hibbits case EXC_PGM: 34128cbb9b1SJustin Hibbits if (frame->srr1 & EXC_PGM_TRAP) { 34228cbb9b1SJustin Hibbits if (*(uint32_t *)frame->srr0 == EXC_DTRACE) { 34328cbb9b1SJustin Hibbits if (dtrace_invop_jump_addr != NULL) { 34428cbb9b1SJustin Hibbits dtrace_invop_jump_addr(frame); 34528cbb9b1SJustin Hibbits return; 34628cbb9b1SJustin Hibbits } 34728cbb9b1SJustin Hibbits } 34828cbb9b1SJustin Hibbits } 34928cbb9b1SJustin Hibbits break; 35028cbb9b1SJustin Hibbits #endif 35128cbb9b1SJustin Hibbits #ifdef __powerpc64__ 35228cbb9b1SJustin Hibbits case EXC_DSE: 35328cbb9b1SJustin Hibbits if ((frame->dar & SEGMENT_MASK) == USER_ADDR) { 35428cbb9b1SJustin Hibbits __asm __volatile ("slbmte %0, %1" :: 35528cbb9b1SJustin Hibbits "r"(td->td_pcb->pcb_cpu.aim.usr_vsid), 35628cbb9b1SJustin Hibbits "r"(USER_SLB_SLBE)); 35728cbb9b1SJustin Hibbits return; 35828cbb9b1SJustin Hibbits } 35928cbb9b1SJustin Hibbits break; 36028cbb9b1SJustin Hibbits #endif 36128cbb9b1SJustin Hibbits case EXC_DSI: 36228cbb9b1SJustin Hibbits if (trap_pfault(frame, 0) == 0) 36328cbb9b1SJustin Hibbits return; 36428cbb9b1SJustin Hibbits break; 36528cbb9b1SJustin Hibbits case EXC_MCHK: 36628cbb9b1SJustin Hibbits if (handle_onfault(frame)) 36728cbb9b1SJustin Hibbits return; 36828cbb9b1SJustin Hibbits break; 36928cbb9b1SJustin Hibbits default: 37028cbb9b1SJustin Hibbits break; 37128cbb9b1SJustin Hibbits } 37228cbb9b1SJustin Hibbits trap_fatal(frame); 37328cbb9b1SJustin Hibbits } 37428cbb9b1SJustin Hibbits 37528cbb9b1SJustin Hibbits if (sig != 0) { 37628cbb9b1SJustin Hibbits if (p->p_sysent->sv_transtrap != NULL) 37728cbb9b1SJustin Hibbits sig = (p->p_sysent->sv_transtrap)(sig, type); 37828cbb9b1SJustin Hibbits ksiginfo_init_trap(&ksi); 37928cbb9b1SJustin Hibbits ksi.ksi_signo = sig; 38028cbb9b1SJustin Hibbits ksi.ksi_code = (int) ucode; /* XXX, not POSIX */ 38128cbb9b1SJustin Hibbits /* ksi.ksi_addr = ? */ 38228cbb9b1SJustin Hibbits ksi.ksi_trapno = type; 38328cbb9b1SJustin Hibbits trapsignal(td, &ksi); 38428cbb9b1SJustin Hibbits } 38528cbb9b1SJustin Hibbits 38628cbb9b1SJustin Hibbits userret(td, frame); 38728cbb9b1SJustin Hibbits } 38828cbb9b1SJustin Hibbits 38928cbb9b1SJustin Hibbits static void 39028cbb9b1SJustin Hibbits trap_fatal(struct trapframe *frame) 39128cbb9b1SJustin Hibbits { 39228cbb9b1SJustin Hibbits 39328cbb9b1SJustin Hibbits printtrap(frame->exc, frame, 1, (frame->srr1 & PSL_PR)); 39428cbb9b1SJustin Hibbits #ifdef KDB 39528cbb9b1SJustin Hibbits if ((debugger_on_panic || kdb_active) && 39628cbb9b1SJustin Hibbits kdb_trap(frame->exc, 0, frame)) 39728cbb9b1SJustin Hibbits return; 39828cbb9b1SJustin Hibbits #endif 39928cbb9b1SJustin Hibbits panic("%s trap", trapname(frame->exc)); 40028cbb9b1SJustin Hibbits } 40128cbb9b1SJustin Hibbits 40228cbb9b1SJustin Hibbits static void 40328cbb9b1SJustin Hibbits printtrap(u_int vector, struct trapframe *frame, int isfatal, int user) 40428cbb9b1SJustin Hibbits { 405398973f8SJustin Hibbits uint16_t ver; 4066035018bSJustin Hibbits #ifdef BOOKE 4076035018bSJustin Hibbits vm_paddr_t pa; 4086035018bSJustin Hibbits #endif 40928cbb9b1SJustin Hibbits 41028cbb9b1SJustin Hibbits printf("\n"); 41128cbb9b1SJustin Hibbits printf("%s %s trap:\n", isfatal ? "fatal" : "handled", 41228cbb9b1SJustin Hibbits user ? "user" : "kernel"); 41328cbb9b1SJustin Hibbits printf("\n"); 41428cbb9b1SJustin Hibbits printf(" exception = 0x%x (%s)\n", vector, trapname(vector)); 41528cbb9b1SJustin Hibbits switch (vector) { 41628cbb9b1SJustin Hibbits case EXC_DSE: 41728cbb9b1SJustin Hibbits case EXC_DSI: 41839a4b70fSJustin Hibbits case EXC_DTMISS: 41928cbb9b1SJustin Hibbits printf(" virtual address = 0x%" PRIxPTR "\n", frame->dar); 42039a4b70fSJustin Hibbits #ifdef AIM 421cf5aa326SJustin Hibbits printf(" dsisr = 0x%lx\n", 422cf5aa326SJustin Hibbits (u_long)frame->cpu.aim.dsisr); 42339a4b70fSJustin Hibbits #endif 42428cbb9b1SJustin Hibbits break; 42528cbb9b1SJustin Hibbits case EXC_ISE: 42628cbb9b1SJustin Hibbits case EXC_ISI: 42739a4b70fSJustin Hibbits case EXC_ITMISS: 42828cbb9b1SJustin Hibbits printf(" virtual address = 0x%" PRIxPTR "\n", frame->srr0); 42928cbb9b1SJustin Hibbits break; 430398973f8SJustin Hibbits case EXC_MCHK: 431398973f8SJustin Hibbits ver = mfpvr() >> 16; 432398973f8SJustin Hibbits #if defined(AIM) 433398973f8SJustin Hibbits if (MPC745X_P(ver)) 43444027a83SJustin Hibbits printf(" msssr0 = 0x%lx\n", 43544027a83SJustin Hibbits (u_long)mfspr(SPR_MSSSR0)); 436398973f8SJustin Hibbits #elif defined(BOOKE) 4376035018bSJustin Hibbits pa = mfspr(SPR_MCARU); 4386035018bSJustin Hibbits pa = (pa << 32) | mfspr(SPR_MCAR); 43944027a83SJustin Hibbits printf(" mcsr = 0x%lx\n", (u_long)mfspr(SPR_MCSR)); 4406035018bSJustin Hibbits printf(" mcar = 0x%jx\n", (uintmax_t)pa); 441398973f8SJustin Hibbits #endif 442398973f8SJustin Hibbits break; 44328cbb9b1SJustin Hibbits } 44439a4b70fSJustin Hibbits #ifdef BOOKE 44539a4b70fSJustin Hibbits printf(" esr = 0x%" PRIxPTR "\n", 44639a4b70fSJustin Hibbits frame->cpu.booke.esr); 44739a4b70fSJustin Hibbits #endif 44828cbb9b1SJustin Hibbits printf(" srr0 = 0x%" PRIxPTR "\n", frame->srr0); 449cf5aa326SJustin Hibbits printf(" srr1 = 0x%lx\n", (u_long)frame->srr1); 45028cbb9b1SJustin Hibbits printf(" lr = 0x%" PRIxPTR "\n", frame->lr); 45128cbb9b1SJustin Hibbits printf(" curthread = %p\n", curthread); 45228cbb9b1SJustin Hibbits if (curthread != NULL) 45328cbb9b1SJustin Hibbits printf(" pid = %d, comm = %s\n", 45428cbb9b1SJustin Hibbits curthread->td_proc->p_pid, curthread->td_name); 45528cbb9b1SJustin Hibbits printf("\n"); 45628cbb9b1SJustin Hibbits } 45728cbb9b1SJustin Hibbits 45828cbb9b1SJustin Hibbits /* 45928cbb9b1SJustin Hibbits * Handles a fatal fault when we have onfault state to recover. Returns 46028cbb9b1SJustin Hibbits * non-zero if there was onfault recovery state available. 46128cbb9b1SJustin Hibbits */ 46228cbb9b1SJustin Hibbits static int 46328cbb9b1SJustin Hibbits handle_onfault(struct trapframe *frame) 46428cbb9b1SJustin Hibbits { 46528cbb9b1SJustin Hibbits struct thread *td; 466a18c313eSNathan Whitehorn jmp_buf *fb; 46728cbb9b1SJustin Hibbits 46828cbb9b1SJustin Hibbits td = curthread; 46928cbb9b1SJustin Hibbits fb = td->td_pcb->pcb_onfault; 47028cbb9b1SJustin Hibbits if (fb != NULL) { 471a18c313eSNathan Whitehorn frame->srr0 = (*fb)->_jb[FAULTBUF_LR]; 472a18c313eSNathan Whitehorn frame->fixreg[1] = (*fb)->_jb[FAULTBUF_R1]; 473a18c313eSNathan Whitehorn frame->fixreg[2] = (*fb)->_jb[FAULTBUF_R2]; 47428cbb9b1SJustin Hibbits frame->fixreg[3] = 1; 475a18c313eSNathan Whitehorn frame->cr = (*fb)->_jb[FAULTBUF_CR]; 476a18c313eSNathan Whitehorn bcopy(&(*fb)->_jb[FAULTBUF_R14], &frame->fixreg[14], 477a18c313eSNathan Whitehorn 18 * sizeof(register_t)); 478a18c313eSNathan Whitehorn td->td_pcb->pcb_onfault = NULL; /* Returns twice, not thrice */ 47928cbb9b1SJustin Hibbits return (1); 48028cbb9b1SJustin Hibbits } 48128cbb9b1SJustin Hibbits return (0); 48228cbb9b1SJustin Hibbits } 48328cbb9b1SJustin Hibbits 48428cbb9b1SJustin Hibbits int 48528cbb9b1SJustin Hibbits cpu_fetch_syscall_args(struct thread *td, struct syscall_args *sa) 48628cbb9b1SJustin Hibbits { 48728cbb9b1SJustin Hibbits struct proc *p; 48828cbb9b1SJustin Hibbits struct trapframe *frame; 48928cbb9b1SJustin Hibbits caddr_t params; 49028cbb9b1SJustin Hibbits size_t argsz; 49128cbb9b1SJustin Hibbits int error, n, i; 49228cbb9b1SJustin Hibbits 49328cbb9b1SJustin Hibbits p = td->td_proc; 49428cbb9b1SJustin Hibbits frame = td->td_frame; 49528cbb9b1SJustin Hibbits 49628cbb9b1SJustin Hibbits sa->code = frame->fixreg[0]; 49728cbb9b1SJustin Hibbits params = (caddr_t)(frame->fixreg + FIRSTARG); 49828cbb9b1SJustin Hibbits n = NARGREG; 49928cbb9b1SJustin Hibbits 50028cbb9b1SJustin Hibbits if (sa->code == SYS_syscall) { 50128cbb9b1SJustin Hibbits /* 50228cbb9b1SJustin Hibbits * code is first argument, 50328cbb9b1SJustin Hibbits * followed by actual args. 50428cbb9b1SJustin Hibbits */ 50528cbb9b1SJustin Hibbits sa->code = *(register_t *) params; 50628cbb9b1SJustin Hibbits params += sizeof(register_t); 50728cbb9b1SJustin Hibbits n -= 1; 50828cbb9b1SJustin Hibbits } else if (sa->code == SYS___syscall) { 50928cbb9b1SJustin Hibbits /* 51028cbb9b1SJustin Hibbits * Like syscall, but code is a quad, 51128cbb9b1SJustin Hibbits * so as to maintain quad alignment 51228cbb9b1SJustin Hibbits * for the rest of the args. 51328cbb9b1SJustin Hibbits */ 51428cbb9b1SJustin Hibbits if (SV_PROC_FLAG(p, SV_ILP32)) { 51528cbb9b1SJustin Hibbits params += sizeof(register_t); 51628cbb9b1SJustin Hibbits sa->code = *(register_t *) params; 51728cbb9b1SJustin Hibbits params += sizeof(register_t); 51828cbb9b1SJustin Hibbits n -= 2; 51928cbb9b1SJustin Hibbits } else { 52028cbb9b1SJustin Hibbits sa->code = *(register_t *) params; 52128cbb9b1SJustin Hibbits params += sizeof(register_t); 52228cbb9b1SJustin Hibbits n -= 1; 52328cbb9b1SJustin Hibbits } 52428cbb9b1SJustin Hibbits } 52528cbb9b1SJustin Hibbits 52628cbb9b1SJustin Hibbits if (p->p_sysent->sv_mask) 52728cbb9b1SJustin Hibbits sa->code &= p->p_sysent->sv_mask; 52828cbb9b1SJustin Hibbits if (sa->code >= p->p_sysent->sv_size) 52928cbb9b1SJustin Hibbits sa->callp = &p->p_sysent->sv_table[0]; 53028cbb9b1SJustin Hibbits else 53128cbb9b1SJustin Hibbits sa->callp = &p->p_sysent->sv_table[sa->code]; 53228cbb9b1SJustin Hibbits 53328cbb9b1SJustin Hibbits sa->narg = sa->callp->sy_narg; 53428cbb9b1SJustin Hibbits 53528cbb9b1SJustin Hibbits if (SV_PROC_FLAG(p, SV_ILP32)) { 53628cbb9b1SJustin Hibbits argsz = sizeof(uint32_t); 53728cbb9b1SJustin Hibbits 53828cbb9b1SJustin Hibbits for (i = 0; i < n; i++) 53928cbb9b1SJustin Hibbits sa->args[i] = ((u_register_t *)(params))[i] & 54028cbb9b1SJustin Hibbits 0xffffffff; 54128cbb9b1SJustin Hibbits } else { 54228cbb9b1SJustin Hibbits argsz = sizeof(uint64_t); 54328cbb9b1SJustin Hibbits 54428cbb9b1SJustin Hibbits for (i = 0; i < n; i++) 54528cbb9b1SJustin Hibbits sa->args[i] = ((u_register_t *)(params))[i]; 54628cbb9b1SJustin Hibbits } 54728cbb9b1SJustin Hibbits 54828cbb9b1SJustin Hibbits if (sa->narg > n) 54928cbb9b1SJustin Hibbits error = copyin(MOREARGS(frame->fixreg[1]), sa->args + n, 55028cbb9b1SJustin Hibbits (sa->narg - n) * argsz); 55128cbb9b1SJustin Hibbits else 55228cbb9b1SJustin Hibbits error = 0; 55328cbb9b1SJustin Hibbits 55428cbb9b1SJustin Hibbits #ifdef __powerpc64__ 55528cbb9b1SJustin Hibbits if (SV_PROC_FLAG(p, SV_ILP32) && sa->narg > n) { 55628cbb9b1SJustin Hibbits /* Expand the size of arguments copied from the stack */ 55728cbb9b1SJustin Hibbits 55828cbb9b1SJustin Hibbits for (i = sa->narg; i >= n; i--) 55928cbb9b1SJustin Hibbits sa->args[i] = ((uint32_t *)(&sa->args[n]))[i-n]; 56028cbb9b1SJustin Hibbits } 56128cbb9b1SJustin Hibbits #endif 56228cbb9b1SJustin Hibbits 56328cbb9b1SJustin Hibbits if (error == 0) { 56428cbb9b1SJustin Hibbits td->td_retval[0] = 0; 56528cbb9b1SJustin Hibbits td->td_retval[1] = frame->fixreg[FIRSTARG + 1]; 56628cbb9b1SJustin Hibbits } 56728cbb9b1SJustin Hibbits return (error); 56828cbb9b1SJustin Hibbits } 56928cbb9b1SJustin Hibbits 57028cbb9b1SJustin Hibbits #include "../../kern/subr_syscall.c" 57128cbb9b1SJustin Hibbits 57228cbb9b1SJustin Hibbits void 57328cbb9b1SJustin Hibbits syscall(struct trapframe *frame) 57428cbb9b1SJustin Hibbits { 57528cbb9b1SJustin Hibbits struct thread *td; 57628cbb9b1SJustin Hibbits struct syscall_args sa; 57728cbb9b1SJustin Hibbits int error; 57828cbb9b1SJustin Hibbits 57928cbb9b1SJustin Hibbits td = curthread; 58028cbb9b1SJustin Hibbits td->td_frame = frame; 58128cbb9b1SJustin Hibbits 58228cbb9b1SJustin Hibbits #ifdef __powerpc64__ 58328cbb9b1SJustin Hibbits /* 58428cbb9b1SJustin Hibbits * Speculatively restore last user SLB segment, which we know is 58528cbb9b1SJustin Hibbits * invalid already, since we are likely to do copyin()/copyout(). 58628cbb9b1SJustin Hibbits */ 58728cbb9b1SJustin Hibbits __asm __volatile ("slbmte %0, %1; isync" :: 58828cbb9b1SJustin Hibbits "r"(td->td_pcb->pcb_cpu.aim.usr_vsid), "r"(USER_SLB_SLBE)); 58928cbb9b1SJustin Hibbits #endif 59028cbb9b1SJustin Hibbits 59128cbb9b1SJustin Hibbits error = syscallenter(td, &sa); 59228cbb9b1SJustin Hibbits syscallret(td, error, &sa); 59328cbb9b1SJustin Hibbits } 59428cbb9b1SJustin Hibbits 59528cbb9b1SJustin Hibbits #ifdef __powerpc64__ 59628cbb9b1SJustin Hibbits /* Handle kernel SLB faults -- runs in real mode, all seat belts off */ 59728cbb9b1SJustin Hibbits void 59828cbb9b1SJustin Hibbits handle_kernel_slb_spill(int type, register_t dar, register_t srr0) 59928cbb9b1SJustin Hibbits { 60028cbb9b1SJustin Hibbits struct slb *slbcache; 60128cbb9b1SJustin Hibbits uint64_t slbe, slbv; 60228cbb9b1SJustin Hibbits uint64_t esid, addr; 60328cbb9b1SJustin Hibbits int i; 60428cbb9b1SJustin Hibbits 60528cbb9b1SJustin Hibbits addr = (type == EXC_ISE) ? srr0 : dar; 60628cbb9b1SJustin Hibbits slbcache = PCPU_GET(slb); 60728cbb9b1SJustin Hibbits esid = (uintptr_t)addr >> ADDR_SR_SHFT; 60828cbb9b1SJustin Hibbits slbe = (esid << SLBE_ESID_SHIFT) | SLBE_VALID; 60928cbb9b1SJustin Hibbits 61028cbb9b1SJustin Hibbits /* See if the hardware flushed this somehow (can happen in LPARs) */ 61128cbb9b1SJustin Hibbits for (i = 0; i < n_slbs; i++) 61228cbb9b1SJustin Hibbits if (slbcache[i].slbe == (slbe | (uint64_t)i)) 61328cbb9b1SJustin Hibbits return; 61428cbb9b1SJustin Hibbits 61528cbb9b1SJustin Hibbits /* Not in the map, needs to actually be added */ 61628cbb9b1SJustin Hibbits slbv = kernel_va_to_slbv(addr); 61728cbb9b1SJustin Hibbits if (slbcache[USER_SLB_SLOT].slbe == 0) { 61828cbb9b1SJustin Hibbits for (i = 0; i < n_slbs; i++) { 61928cbb9b1SJustin Hibbits if (i == USER_SLB_SLOT) 62028cbb9b1SJustin Hibbits continue; 62128cbb9b1SJustin Hibbits if (!(slbcache[i].slbe & SLBE_VALID)) 62228cbb9b1SJustin Hibbits goto fillkernslb; 62328cbb9b1SJustin Hibbits } 62428cbb9b1SJustin Hibbits 62528cbb9b1SJustin Hibbits if (i == n_slbs) 62628cbb9b1SJustin Hibbits slbcache[USER_SLB_SLOT].slbe = 1; 62728cbb9b1SJustin Hibbits } 62828cbb9b1SJustin Hibbits 62928cbb9b1SJustin Hibbits /* Sacrifice a random SLB entry that is not the user entry */ 63028cbb9b1SJustin Hibbits i = mftb() % n_slbs; 63128cbb9b1SJustin Hibbits if (i == USER_SLB_SLOT) 63228cbb9b1SJustin Hibbits i = (i+1) % n_slbs; 63328cbb9b1SJustin Hibbits 63428cbb9b1SJustin Hibbits fillkernslb: 63528cbb9b1SJustin Hibbits /* Write new entry */ 63628cbb9b1SJustin Hibbits slbcache[i].slbv = slbv; 63728cbb9b1SJustin Hibbits slbcache[i].slbe = slbe | (uint64_t)i; 63828cbb9b1SJustin Hibbits 63928cbb9b1SJustin Hibbits /* Trap handler will restore from cache on exit */ 64028cbb9b1SJustin Hibbits } 64128cbb9b1SJustin Hibbits 64228cbb9b1SJustin Hibbits static int 64328cbb9b1SJustin Hibbits handle_user_slb_spill(pmap_t pm, vm_offset_t addr) 64428cbb9b1SJustin Hibbits { 64528cbb9b1SJustin Hibbits struct slb *user_entry; 64628cbb9b1SJustin Hibbits uint64_t esid; 64728cbb9b1SJustin Hibbits int i; 64828cbb9b1SJustin Hibbits 64928cbb9b1SJustin Hibbits esid = (uintptr_t)addr >> ADDR_SR_SHFT; 65028cbb9b1SJustin Hibbits 65128cbb9b1SJustin Hibbits PMAP_LOCK(pm); 65228cbb9b1SJustin Hibbits user_entry = user_va_to_slb_entry(pm, addr); 65328cbb9b1SJustin Hibbits 65428cbb9b1SJustin Hibbits if (user_entry == NULL) { 65528cbb9b1SJustin Hibbits /* allocate_vsid auto-spills it */ 65628cbb9b1SJustin Hibbits (void)allocate_user_vsid(pm, esid, 0); 65728cbb9b1SJustin Hibbits } else { 65828cbb9b1SJustin Hibbits /* 65928cbb9b1SJustin Hibbits * Check that another CPU has not already mapped this. 66028cbb9b1SJustin Hibbits * XXX: Per-thread SLB caches would be better. 66128cbb9b1SJustin Hibbits */ 66228cbb9b1SJustin Hibbits for (i = 0; i < pm->pm_slb_len; i++) 66328cbb9b1SJustin Hibbits if (pm->pm_slb[i] == user_entry) 66428cbb9b1SJustin Hibbits break; 66528cbb9b1SJustin Hibbits 66628cbb9b1SJustin Hibbits if (i == pm->pm_slb_len) 66728cbb9b1SJustin Hibbits slb_insert_user(pm, user_entry); 66828cbb9b1SJustin Hibbits } 66928cbb9b1SJustin Hibbits PMAP_UNLOCK(pm); 67028cbb9b1SJustin Hibbits 67128cbb9b1SJustin Hibbits return (0); 67228cbb9b1SJustin Hibbits } 67328cbb9b1SJustin Hibbits #endif 67428cbb9b1SJustin Hibbits 67528cbb9b1SJustin Hibbits static int 67628cbb9b1SJustin Hibbits trap_pfault(struct trapframe *frame, int user) 67728cbb9b1SJustin Hibbits { 67828cbb9b1SJustin Hibbits vm_offset_t eva, va; 67928cbb9b1SJustin Hibbits struct thread *td; 68028cbb9b1SJustin Hibbits struct proc *p; 68128cbb9b1SJustin Hibbits vm_map_t map; 68228cbb9b1SJustin Hibbits vm_prot_t ftype; 68328cbb9b1SJustin Hibbits int rv; 68428cbb9b1SJustin Hibbits #ifdef AIM 68528cbb9b1SJustin Hibbits register_t user_sr; 68628cbb9b1SJustin Hibbits #endif 68728cbb9b1SJustin Hibbits 68828cbb9b1SJustin Hibbits td = curthread; 68928cbb9b1SJustin Hibbits p = td->td_proc; 69028cbb9b1SJustin Hibbits if (frame->exc == EXC_ISI) { 69128cbb9b1SJustin Hibbits eva = frame->srr0; 69228cbb9b1SJustin Hibbits ftype = VM_PROT_EXECUTE; 69328cbb9b1SJustin Hibbits if (frame->srr1 & SRR1_ISI_PFAULT) 69428cbb9b1SJustin Hibbits ftype |= VM_PROT_READ; 69528cbb9b1SJustin Hibbits } else { 69628cbb9b1SJustin Hibbits eva = frame->dar; 69728cbb9b1SJustin Hibbits #ifdef BOOKE 69828cbb9b1SJustin Hibbits if (frame->cpu.booke.esr & ESR_ST) 69928cbb9b1SJustin Hibbits #else 70028cbb9b1SJustin Hibbits if (frame->cpu.aim.dsisr & DSISR_STORE) 70128cbb9b1SJustin Hibbits #endif 70228cbb9b1SJustin Hibbits ftype = VM_PROT_WRITE; 70328cbb9b1SJustin Hibbits else 70428cbb9b1SJustin Hibbits ftype = VM_PROT_READ; 70528cbb9b1SJustin Hibbits } 70628cbb9b1SJustin Hibbits 70728cbb9b1SJustin Hibbits if (user) { 70828cbb9b1SJustin Hibbits KASSERT(p->p_vmspace != NULL, ("trap_pfault: vmspace NULL")); 70928cbb9b1SJustin Hibbits map = &p->p_vmspace->vm_map; 71028cbb9b1SJustin Hibbits } else { 71128cbb9b1SJustin Hibbits #ifdef BOOKE 71228cbb9b1SJustin Hibbits if (eva < VM_MAXUSER_ADDRESS) { 71328cbb9b1SJustin Hibbits #else 71428cbb9b1SJustin Hibbits if ((eva >> ADDR_SR_SHFT) == (USER_ADDR >> ADDR_SR_SHFT)) { 71528cbb9b1SJustin Hibbits #endif 71628cbb9b1SJustin Hibbits map = &p->p_vmspace->vm_map; 71728cbb9b1SJustin Hibbits 71828cbb9b1SJustin Hibbits #ifdef AIM 71928cbb9b1SJustin Hibbits user_sr = td->td_pcb->pcb_cpu.aim.usr_segm; 72028cbb9b1SJustin Hibbits eva &= ADDR_PIDX | ADDR_POFF; 72128cbb9b1SJustin Hibbits eva |= user_sr << ADDR_SR_SHFT; 72228cbb9b1SJustin Hibbits #endif 72328cbb9b1SJustin Hibbits } else { 72428cbb9b1SJustin Hibbits map = kernel_map; 72528cbb9b1SJustin Hibbits } 72628cbb9b1SJustin Hibbits } 72728cbb9b1SJustin Hibbits va = trunc_page(eva); 72828cbb9b1SJustin Hibbits 7291fa67124SKonstantin Belousov /* Fault in the page. */ 73028cbb9b1SJustin Hibbits rv = vm_fault(map, va, ftype, VM_FAULT_NORMAL); 73128cbb9b1SJustin Hibbits /* 73228cbb9b1SJustin Hibbits * XXXDTRACE: add dtrace_doubletrap_func here? 73328cbb9b1SJustin Hibbits */ 73428cbb9b1SJustin Hibbits 73528cbb9b1SJustin Hibbits if (rv == KERN_SUCCESS) 73628cbb9b1SJustin Hibbits return (0); 73728cbb9b1SJustin Hibbits 73828cbb9b1SJustin Hibbits if (!user && handle_onfault(frame)) 73928cbb9b1SJustin Hibbits return (0); 74028cbb9b1SJustin Hibbits 74128cbb9b1SJustin Hibbits return (SIGSEGV); 74228cbb9b1SJustin Hibbits } 74328cbb9b1SJustin Hibbits 74428cbb9b1SJustin Hibbits /* 74528cbb9b1SJustin Hibbits * For now, this only deals with the particular unaligned access case 74628cbb9b1SJustin Hibbits * that gcc tends to generate. Eventually it should handle all of the 74728cbb9b1SJustin Hibbits * possibilities that can happen on a 32-bit PowerPC in big-endian mode. 74828cbb9b1SJustin Hibbits */ 74928cbb9b1SJustin Hibbits 75028cbb9b1SJustin Hibbits static int 75128cbb9b1SJustin Hibbits fix_unaligned(struct thread *td, struct trapframe *frame) 75228cbb9b1SJustin Hibbits { 75328cbb9b1SJustin Hibbits struct thread *fputhread; 75428cbb9b1SJustin Hibbits int indicator, reg; 75528cbb9b1SJustin Hibbits double *fpr; 75628cbb9b1SJustin Hibbits 75728cbb9b1SJustin Hibbits indicator = EXC_ALI_OPCODE_INDICATOR(frame->cpu.aim.dsisr); 75828cbb9b1SJustin Hibbits 75928cbb9b1SJustin Hibbits switch (indicator) { 76028cbb9b1SJustin Hibbits case EXC_ALI_LFD: 76128cbb9b1SJustin Hibbits case EXC_ALI_STFD: 76228cbb9b1SJustin Hibbits reg = EXC_ALI_RST(frame->cpu.aim.dsisr); 76328cbb9b1SJustin Hibbits fpr = &td->td_pcb->pcb_fpu.fpr[reg].fpr; 76428cbb9b1SJustin Hibbits fputhread = PCPU_GET(fputhread); 76528cbb9b1SJustin Hibbits 76628cbb9b1SJustin Hibbits /* Juggle the FPU to ensure that we've initialized 76728cbb9b1SJustin Hibbits * the FPRs, and that their current state is in 76828cbb9b1SJustin Hibbits * the PCB. 76928cbb9b1SJustin Hibbits */ 77028cbb9b1SJustin Hibbits if (fputhread != td) { 77128cbb9b1SJustin Hibbits if (fputhread) 77228cbb9b1SJustin Hibbits save_fpu(fputhread); 77328cbb9b1SJustin Hibbits enable_fpu(td); 77428cbb9b1SJustin Hibbits } 77528cbb9b1SJustin Hibbits save_fpu(td); 77628cbb9b1SJustin Hibbits 77728cbb9b1SJustin Hibbits if (indicator == EXC_ALI_LFD) { 77828cbb9b1SJustin Hibbits if (copyin((void *)frame->dar, fpr, 77928cbb9b1SJustin Hibbits sizeof(double)) != 0) 78028cbb9b1SJustin Hibbits return (-1); 78128cbb9b1SJustin Hibbits enable_fpu(td); 78228cbb9b1SJustin Hibbits } else { 78328cbb9b1SJustin Hibbits if (copyout(fpr, (void *)frame->dar, 78428cbb9b1SJustin Hibbits sizeof(double)) != 0) 78528cbb9b1SJustin Hibbits return (-1); 78628cbb9b1SJustin Hibbits } 78728cbb9b1SJustin Hibbits return (0); 78828cbb9b1SJustin Hibbits break; 78928cbb9b1SJustin Hibbits } 79028cbb9b1SJustin Hibbits 79128cbb9b1SJustin Hibbits return (-1); 79228cbb9b1SJustin Hibbits } 79328cbb9b1SJustin Hibbits 79428cbb9b1SJustin Hibbits #ifdef KDB 79528cbb9b1SJustin Hibbits int db_trap_glue(struct trapframe *); /* Called from trap_subr.S */ 79628cbb9b1SJustin Hibbits 79728cbb9b1SJustin Hibbits int 79828cbb9b1SJustin Hibbits db_trap_glue(struct trapframe *frame) 79928cbb9b1SJustin Hibbits { 80028cbb9b1SJustin Hibbits if (!(frame->srr1 & PSL_PR) 80128cbb9b1SJustin Hibbits && (frame->exc == EXC_TRC || frame->exc == EXC_RUNMODETRC 802e3e38bc7SJustin Hibbits #ifdef AIM 80328cbb9b1SJustin Hibbits || (frame->exc == EXC_PGM 8047a67c1f8SJustin Hibbits && (frame->srr1 & EXC_PGM_TRAP)) 805e3e38bc7SJustin Hibbits #else 806e3e38bc7SJustin Hibbits || (frame->exc == EXC_DEBUG) 807e3e38bc7SJustin Hibbits #endif 80828cbb9b1SJustin Hibbits || frame->exc == EXC_BPT 80928cbb9b1SJustin Hibbits || frame->exc == EXC_DSI)) { 81028cbb9b1SJustin Hibbits int type = frame->exc; 81128cbb9b1SJustin Hibbits 81228cbb9b1SJustin Hibbits /* Ignore DTrace traps. */ 81328cbb9b1SJustin Hibbits if (*(uint32_t *)frame->srr0 == EXC_DTRACE) 81428cbb9b1SJustin Hibbits return (0); 815e3e38bc7SJustin Hibbits #ifdef AIM 8167a67c1f8SJustin Hibbits if (type == EXC_PGM && (frame->srr1 & EXC_PGM_TRAP)) { 817e3e38bc7SJustin Hibbits #else 818e3e38bc7SJustin Hibbits if (frame->cpu.booke.esr & ESR_PTR) { 819e3e38bc7SJustin Hibbits #endif 82028cbb9b1SJustin Hibbits type = T_BREAKPOINT; 82128cbb9b1SJustin Hibbits } 82228cbb9b1SJustin Hibbits return (kdb_trap(type, 0, frame)); 82328cbb9b1SJustin Hibbits } 82428cbb9b1SJustin Hibbits 82528cbb9b1SJustin Hibbits return (0); 82628cbb9b1SJustin Hibbits } 82728cbb9b1SJustin Hibbits #endif 828