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 833e7e31bdSJustin Hibbits #define MOREARGS(sp) ((caddr_t)((uintptr_t)(sp) + \ 843e7e31bdSJustin Hibbits sizeof(struct callframe) - 3*sizeof(register_t))) /* more args go here */ 853e7e31bdSJustin Hibbits 8628cbb9b1SJustin Hibbits static void trap_fatal(struct trapframe *frame); 8728cbb9b1SJustin Hibbits static void printtrap(u_int vector, struct trapframe *frame, int isfatal, 8828cbb9b1SJustin Hibbits int user); 8928cbb9b1SJustin Hibbits static int trap_pfault(struct trapframe *frame, int user); 9028cbb9b1SJustin Hibbits static int fix_unaligned(struct thread *td, struct trapframe *frame); 9128cbb9b1SJustin Hibbits static int handle_onfault(struct trapframe *frame); 9228cbb9b1SJustin Hibbits static void syscall(struct trapframe *frame); 9328cbb9b1SJustin Hibbits 94d5a30121SJustin Hibbits #if defined(__powerpc64__) && defined(AIM) 9528cbb9b1SJustin Hibbits void handle_kernel_slb_spill(int, register_t, register_t); 9628cbb9b1SJustin Hibbits static int handle_user_slb_spill(pmap_t pm, vm_offset_t addr); 9728cbb9b1SJustin Hibbits extern int n_slbs; 9828cbb9b1SJustin Hibbits #endif 9928cbb9b1SJustin Hibbits 10015fc4ab7SJustin Hibbits #ifdef KDB 10115fc4ab7SJustin Hibbits int db_trap_glue(struct trapframe *); /* Called from trap_subr.S */ 10215fc4ab7SJustin Hibbits #endif 10315fc4ab7SJustin Hibbits 10428cbb9b1SJustin Hibbits struct powerpc_exception { 10528cbb9b1SJustin Hibbits u_int vector; 10628cbb9b1SJustin Hibbits char *name; 10728cbb9b1SJustin Hibbits }; 10828cbb9b1SJustin Hibbits 10928cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS 11028cbb9b1SJustin Hibbits #include <sys/dtrace_bsd.h> 11128cbb9b1SJustin Hibbits 11228cbb9b1SJustin Hibbits int (*dtrace_invop_jump_addr)(struct trapframe *); 11328cbb9b1SJustin Hibbits #endif 11428cbb9b1SJustin Hibbits 11528cbb9b1SJustin Hibbits static struct powerpc_exception powerpc_exceptions[] = { 11628cbb9b1SJustin Hibbits { EXC_CRIT, "critical input" }, 11728cbb9b1SJustin Hibbits { EXC_RST, "system reset" }, 11828cbb9b1SJustin Hibbits { EXC_MCHK, "machine check" }, 11928cbb9b1SJustin Hibbits { EXC_DSI, "data storage interrupt" }, 12028cbb9b1SJustin Hibbits { EXC_DSE, "data segment exception" }, 12128cbb9b1SJustin Hibbits { EXC_ISI, "instruction storage interrupt" }, 12228cbb9b1SJustin Hibbits { EXC_ISE, "instruction segment exception" }, 12328cbb9b1SJustin Hibbits { EXC_EXI, "external interrupt" }, 12428cbb9b1SJustin Hibbits { EXC_ALI, "alignment" }, 12528cbb9b1SJustin Hibbits { EXC_PGM, "program" }, 12628cbb9b1SJustin Hibbits { EXC_FPU, "floating-point unavailable" }, 12728cbb9b1SJustin Hibbits { EXC_APU, "auxiliary proc unavailable" }, 12828cbb9b1SJustin Hibbits { EXC_DECR, "decrementer" }, 12928cbb9b1SJustin Hibbits { EXC_FIT, "fixed-interval timer" }, 13028cbb9b1SJustin Hibbits { EXC_WDOG, "watchdog timer" }, 13128cbb9b1SJustin Hibbits { EXC_SC, "system call" }, 13228cbb9b1SJustin Hibbits { EXC_TRC, "trace" }, 13328cbb9b1SJustin Hibbits { EXC_FPA, "floating-point assist" }, 13428cbb9b1SJustin Hibbits { EXC_DEBUG, "debug" }, 13528cbb9b1SJustin Hibbits { EXC_PERF, "performance monitoring" }, 13628cbb9b1SJustin Hibbits { EXC_VEC, "altivec unavailable" }, 13728cbb9b1SJustin Hibbits { EXC_VSX, "vsx unavailable" }, 13828cbb9b1SJustin Hibbits { EXC_ITMISS, "instruction tlb miss" }, 13928cbb9b1SJustin Hibbits { EXC_DLMISS, "data load tlb miss" }, 14028cbb9b1SJustin Hibbits { EXC_DSMISS, "data store tlb miss" }, 14128cbb9b1SJustin Hibbits { EXC_BPT, "instruction breakpoint" }, 14228cbb9b1SJustin Hibbits { EXC_SMI, "system management" }, 14328cbb9b1SJustin Hibbits { EXC_VECAST_G4, "altivec assist" }, 14428cbb9b1SJustin Hibbits { EXC_THRM, "thermal management" }, 14528cbb9b1SJustin Hibbits { EXC_RUNMODETRC, "run mode/trace" }, 14628cbb9b1SJustin Hibbits { EXC_LAST, NULL } 14728cbb9b1SJustin Hibbits }; 14828cbb9b1SJustin Hibbits 14928cbb9b1SJustin Hibbits static const char * 15028cbb9b1SJustin Hibbits trapname(u_int vector) 15128cbb9b1SJustin Hibbits { 15228cbb9b1SJustin Hibbits struct powerpc_exception *pe; 15328cbb9b1SJustin Hibbits 15428cbb9b1SJustin Hibbits for (pe = powerpc_exceptions; pe->vector != EXC_LAST; pe++) { 15528cbb9b1SJustin Hibbits if (pe->vector == vector) 15628cbb9b1SJustin Hibbits return (pe->name); 15728cbb9b1SJustin Hibbits } 15828cbb9b1SJustin Hibbits 15928cbb9b1SJustin Hibbits return ("unknown"); 16028cbb9b1SJustin Hibbits } 16128cbb9b1SJustin Hibbits 16228cbb9b1SJustin Hibbits void 16328cbb9b1SJustin Hibbits trap(struct trapframe *frame) 16428cbb9b1SJustin Hibbits { 16528cbb9b1SJustin Hibbits struct thread *td; 16628cbb9b1SJustin Hibbits struct proc *p; 16728cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS 16828cbb9b1SJustin Hibbits uint32_t inst; 16928cbb9b1SJustin Hibbits #endif 17028cbb9b1SJustin Hibbits int sig, type, user; 17128cbb9b1SJustin Hibbits u_int ucode; 17228cbb9b1SJustin Hibbits ksiginfo_t ksi; 17328cbb9b1SJustin Hibbits 17483c9dea1SGleb Smirnoff VM_CNT_INC(v_trap); 17528cbb9b1SJustin Hibbits 17628cbb9b1SJustin Hibbits td = curthread; 17728cbb9b1SJustin Hibbits p = td->td_proc; 17828cbb9b1SJustin Hibbits 17928cbb9b1SJustin Hibbits type = ucode = frame->exc; 18028cbb9b1SJustin Hibbits sig = 0; 18128cbb9b1SJustin Hibbits user = frame->srr1 & PSL_PR; 18228cbb9b1SJustin Hibbits 18328cbb9b1SJustin Hibbits CTR3(KTR_TRAP, "trap: %s type=%s (%s)", td->td_name, 18428cbb9b1SJustin Hibbits trapname(type), user ? "user" : "kernel"); 18528cbb9b1SJustin Hibbits 18628cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS 18728cbb9b1SJustin Hibbits /* 18828cbb9b1SJustin Hibbits * A trap can occur while DTrace executes a probe. Before 18928cbb9b1SJustin Hibbits * executing the probe, DTrace blocks re-scheduling and sets 19028cbb9b1SJustin Hibbits * a flag in its per-cpu flags to indicate that it doesn't 19128cbb9b1SJustin Hibbits * want to fault. On returning from the probe, the no-fault 19228cbb9b1SJustin Hibbits * flag is cleared and finally re-scheduling is enabled. 19328cbb9b1SJustin Hibbits * 19428cbb9b1SJustin Hibbits * If the DTrace kernel module has registered a trap handler, 19528cbb9b1SJustin Hibbits * call it and if it returns non-zero, assume that it has 19628cbb9b1SJustin Hibbits * handled the trap and modified the trap frame so that this 19728cbb9b1SJustin Hibbits * function can return normally. 19828cbb9b1SJustin Hibbits */ 19928cbb9b1SJustin Hibbits if (dtrace_trap_func != NULL && (*dtrace_trap_func)(frame, type) != 0) 20028cbb9b1SJustin Hibbits return; 20128cbb9b1SJustin Hibbits #endif 20228cbb9b1SJustin Hibbits 20328cbb9b1SJustin Hibbits if (user) { 20428cbb9b1SJustin Hibbits td->td_pticks = 0; 20528cbb9b1SJustin Hibbits td->td_frame = frame; 2064ea6a9a2SMateusz Guzik if (td->td_cowgen != p->p_cowgen) 2074ea6a9a2SMateusz Guzik thread_cow_update(td); 20828cbb9b1SJustin Hibbits 20928cbb9b1SJustin Hibbits /* User Mode Traps */ 21028cbb9b1SJustin Hibbits switch (type) { 21128cbb9b1SJustin Hibbits case EXC_RUNMODETRC: 21228cbb9b1SJustin Hibbits case EXC_TRC: 21328cbb9b1SJustin Hibbits frame->srr1 &= ~PSL_SE; 21428cbb9b1SJustin Hibbits sig = SIGTRAP; 21528cbb9b1SJustin Hibbits ucode = TRAP_TRACE; 21628cbb9b1SJustin Hibbits break; 21728cbb9b1SJustin Hibbits 218d5a30121SJustin Hibbits #if defined(__powerpc64__) && defined(AIM) 21928cbb9b1SJustin Hibbits case EXC_ISE: 22028cbb9b1SJustin Hibbits case EXC_DSE: 22128cbb9b1SJustin Hibbits if (handle_user_slb_spill(&p->p_vmspace->vm_pmap, 22228cbb9b1SJustin Hibbits (type == EXC_ISE) ? frame->srr0 : frame->dar) != 0){ 22328cbb9b1SJustin Hibbits sig = SIGSEGV; 22428cbb9b1SJustin Hibbits ucode = SEGV_MAPERR; 22528cbb9b1SJustin Hibbits } 22628cbb9b1SJustin Hibbits break; 22728cbb9b1SJustin Hibbits #endif 22828cbb9b1SJustin Hibbits case EXC_DSI: 22928cbb9b1SJustin Hibbits case EXC_ISI: 23028cbb9b1SJustin Hibbits sig = trap_pfault(frame, 1); 23128cbb9b1SJustin Hibbits if (sig == SIGSEGV) 23228cbb9b1SJustin Hibbits ucode = SEGV_MAPERR; 23328cbb9b1SJustin Hibbits break; 23428cbb9b1SJustin Hibbits 23528cbb9b1SJustin Hibbits case EXC_SC: 23628cbb9b1SJustin Hibbits syscall(frame); 23728cbb9b1SJustin Hibbits break; 23828cbb9b1SJustin Hibbits 23928cbb9b1SJustin Hibbits case EXC_FPU: 24028cbb9b1SJustin Hibbits KASSERT((td->td_pcb->pcb_flags & PCB_FPU) != PCB_FPU, 24128cbb9b1SJustin Hibbits ("FPU already enabled for thread")); 24228cbb9b1SJustin Hibbits enable_fpu(td); 24328cbb9b1SJustin Hibbits break; 24428cbb9b1SJustin Hibbits 24528cbb9b1SJustin Hibbits case EXC_VEC: 24628cbb9b1SJustin Hibbits KASSERT((td->td_pcb->pcb_flags & PCB_VEC) != PCB_VEC, 24728cbb9b1SJustin Hibbits ("Altivec already enabled for thread")); 24828cbb9b1SJustin Hibbits enable_vec(td); 24928cbb9b1SJustin Hibbits break; 25028cbb9b1SJustin Hibbits 25128cbb9b1SJustin Hibbits case EXC_VSX: 25228cbb9b1SJustin Hibbits KASSERT((td->td_pcb->pcb_flags & PCB_VSX) != PCB_VSX, 25328cbb9b1SJustin Hibbits ("VSX already enabled for thread")); 25428cbb9b1SJustin Hibbits if (!(td->td_pcb->pcb_flags & PCB_VEC)) 25528cbb9b1SJustin Hibbits enable_vec(td); 25628cbb9b1SJustin Hibbits if (!(td->td_pcb->pcb_flags & PCB_FPU)) 25728cbb9b1SJustin Hibbits save_fpu(td); 25828cbb9b1SJustin Hibbits td->td_pcb->pcb_flags |= PCB_VSX; 25928cbb9b1SJustin Hibbits enable_fpu(td); 26028cbb9b1SJustin Hibbits break; 26128cbb9b1SJustin Hibbits 262541c5806SJustin Hibbits case EXC_VECAST_E: 26328cbb9b1SJustin Hibbits case EXC_VECAST_G4: 26428cbb9b1SJustin Hibbits case EXC_VECAST_G5: 26528cbb9b1SJustin Hibbits /* 26628cbb9b1SJustin Hibbits * We get a VPU assist exception for IEEE mode 26728cbb9b1SJustin Hibbits * vector operations on denormalized floats. 26828cbb9b1SJustin Hibbits * Emulating this is a giant pain, so for now, 26928cbb9b1SJustin Hibbits * just switch off IEEE mode and treat them as 27028cbb9b1SJustin Hibbits * zero. 27128cbb9b1SJustin Hibbits */ 27228cbb9b1SJustin Hibbits 27328cbb9b1SJustin Hibbits save_vec(td); 27428cbb9b1SJustin Hibbits td->td_pcb->pcb_vec.vscr |= ALTIVEC_VSCR_NJ; 27528cbb9b1SJustin Hibbits enable_vec(td); 27628cbb9b1SJustin Hibbits break; 27728cbb9b1SJustin Hibbits 27828cbb9b1SJustin Hibbits case EXC_ALI: 27928cbb9b1SJustin Hibbits if (fix_unaligned(td, frame) != 0) { 28028cbb9b1SJustin Hibbits sig = SIGBUS; 28128cbb9b1SJustin Hibbits ucode = BUS_ADRALN; 28228cbb9b1SJustin Hibbits } 28328cbb9b1SJustin Hibbits else 28428cbb9b1SJustin Hibbits frame->srr0 += 4; 28528cbb9b1SJustin Hibbits break; 28628cbb9b1SJustin Hibbits 28728cbb9b1SJustin Hibbits case EXC_DEBUG: /* Single stepping */ 28828cbb9b1SJustin Hibbits mtspr(SPR_DBSR, mfspr(SPR_DBSR)); 28928cbb9b1SJustin Hibbits frame->srr1 &= ~PSL_DE; 290fa133b6bSJustin Hibbits frame->cpu.booke.dbcr0 &= ~(DBCR0_IDM | DBCR0_IC); 29128cbb9b1SJustin Hibbits sig = SIGTRAP; 29228cbb9b1SJustin Hibbits ucode = TRAP_TRACE; 29328cbb9b1SJustin Hibbits break; 29428cbb9b1SJustin Hibbits 29528cbb9b1SJustin Hibbits case EXC_PGM: 29628cbb9b1SJustin Hibbits /* Identify the trap reason */ 29728cbb9b1SJustin Hibbits #ifdef AIM 29828cbb9b1SJustin Hibbits if (frame->srr1 & EXC_PGM_TRAP) { 29928cbb9b1SJustin Hibbits #else 30028cbb9b1SJustin Hibbits if (frame->cpu.booke.esr & ESR_PTR) { 30128cbb9b1SJustin Hibbits #endif 30228cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS 30328cbb9b1SJustin Hibbits inst = fuword32((const void *)frame->srr0); 30428cbb9b1SJustin Hibbits if (inst == 0x0FFFDDDD && 30528cbb9b1SJustin Hibbits dtrace_pid_probe_ptr != NULL) { 30628cbb9b1SJustin Hibbits struct reg regs; 30728cbb9b1SJustin Hibbits fill_regs(td, ®s); 30828cbb9b1SJustin Hibbits (*dtrace_pid_probe_ptr)(®s); 30928cbb9b1SJustin Hibbits break; 31028cbb9b1SJustin Hibbits } 31128cbb9b1SJustin Hibbits #endif 31228cbb9b1SJustin Hibbits sig = SIGTRAP; 31328cbb9b1SJustin Hibbits ucode = TRAP_BRKPT; 31428cbb9b1SJustin Hibbits } else { 31528cbb9b1SJustin Hibbits sig = ppc_instr_emulate(frame, td->td_pcb); 31628cbb9b1SJustin Hibbits if (sig == SIGILL) { 31728cbb9b1SJustin Hibbits if (frame->srr1 & EXC_PGM_PRIV) 31828cbb9b1SJustin Hibbits ucode = ILL_PRVOPC; 31928cbb9b1SJustin Hibbits else if (frame->srr1 & EXC_PGM_ILLEGAL) 32028cbb9b1SJustin Hibbits ucode = ILL_ILLOPC; 32128cbb9b1SJustin Hibbits } else if (sig == SIGFPE) 32228cbb9b1SJustin Hibbits ucode = FPE_FLTINV; /* Punt for now, invalid operation. */ 32328cbb9b1SJustin Hibbits } 32428cbb9b1SJustin Hibbits break; 32528cbb9b1SJustin Hibbits 32628cbb9b1SJustin Hibbits case EXC_MCHK: 32728cbb9b1SJustin Hibbits /* 32828cbb9b1SJustin Hibbits * Note that this may not be recoverable for the user 32928cbb9b1SJustin Hibbits * process, depending on the type of machine check, 33028cbb9b1SJustin Hibbits * but it at least prevents the kernel from dying. 33128cbb9b1SJustin Hibbits */ 33228cbb9b1SJustin Hibbits sig = SIGBUS; 33328cbb9b1SJustin Hibbits ucode = BUS_OBJERR; 33428cbb9b1SJustin Hibbits break; 33528cbb9b1SJustin Hibbits 33628cbb9b1SJustin Hibbits default: 33728cbb9b1SJustin Hibbits trap_fatal(frame); 33828cbb9b1SJustin Hibbits } 33928cbb9b1SJustin Hibbits } else { 34028cbb9b1SJustin Hibbits /* Kernel Mode Traps */ 34128cbb9b1SJustin Hibbits 34228cbb9b1SJustin Hibbits KASSERT(cold || td->td_ucred != NULL, 34328cbb9b1SJustin Hibbits ("kernel trap doesn't have ucred")); 34428cbb9b1SJustin Hibbits switch (type) { 34528cbb9b1SJustin Hibbits case EXC_PGM: 34615fc4ab7SJustin Hibbits #ifdef KDTRACE_HOOKS 34715fc4ab7SJustin Hibbits #ifdef AIM 34828cbb9b1SJustin Hibbits if (frame->srr1 & EXC_PGM_TRAP) { 34915fc4ab7SJustin Hibbits #else 35015fc4ab7SJustin Hibbits if (frame->cpu.booke.esr & ESR_PTR) { 35115fc4ab7SJustin Hibbits #endif 35228cbb9b1SJustin Hibbits if (*(uint32_t *)frame->srr0 == EXC_DTRACE) { 35328cbb9b1SJustin Hibbits if (dtrace_invop_jump_addr != NULL) { 35428cbb9b1SJustin Hibbits dtrace_invop_jump_addr(frame); 35528cbb9b1SJustin Hibbits return; 35628cbb9b1SJustin Hibbits } 35728cbb9b1SJustin Hibbits } 35828cbb9b1SJustin Hibbits } 35928cbb9b1SJustin Hibbits #endif 36015fc4ab7SJustin Hibbits #ifdef KDB 36115fc4ab7SJustin Hibbits if (db_trap_glue(frame)) 36215fc4ab7SJustin Hibbits return; 36315fc4ab7SJustin Hibbits #endif 36415fc4ab7SJustin Hibbits break; 365d5a30121SJustin Hibbits #if defined(__powerpc64__) && defined(AIM) 36628cbb9b1SJustin Hibbits case EXC_DSE: 36728cbb9b1SJustin Hibbits if ((frame->dar & SEGMENT_MASK) == USER_ADDR) { 36828cbb9b1SJustin Hibbits __asm __volatile ("slbmte %0, %1" :: 36928cbb9b1SJustin Hibbits "r"(td->td_pcb->pcb_cpu.aim.usr_vsid), 37028cbb9b1SJustin Hibbits "r"(USER_SLB_SLBE)); 37128cbb9b1SJustin Hibbits return; 37228cbb9b1SJustin Hibbits } 37328cbb9b1SJustin Hibbits break; 37428cbb9b1SJustin Hibbits #endif 37528cbb9b1SJustin Hibbits case EXC_DSI: 37628cbb9b1SJustin Hibbits if (trap_pfault(frame, 0) == 0) 37728cbb9b1SJustin Hibbits return; 37828cbb9b1SJustin Hibbits break; 37928cbb9b1SJustin Hibbits case EXC_MCHK: 38028cbb9b1SJustin Hibbits if (handle_onfault(frame)) 38128cbb9b1SJustin Hibbits return; 38228cbb9b1SJustin Hibbits break; 38328cbb9b1SJustin Hibbits default: 38428cbb9b1SJustin Hibbits break; 38528cbb9b1SJustin Hibbits } 38628cbb9b1SJustin Hibbits trap_fatal(frame); 38728cbb9b1SJustin Hibbits } 38828cbb9b1SJustin Hibbits 38928cbb9b1SJustin Hibbits if (sig != 0) { 39028cbb9b1SJustin Hibbits if (p->p_sysent->sv_transtrap != NULL) 39128cbb9b1SJustin Hibbits sig = (p->p_sysent->sv_transtrap)(sig, type); 39228cbb9b1SJustin Hibbits ksiginfo_init_trap(&ksi); 39328cbb9b1SJustin Hibbits ksi.ksi_signo = sig; 39428cbb9b1SJustin Hibbits ksi.ksi_code = (int) ucode; /* XXX, not POSIX */ 39528cbb9b1SJustin Hibbits /* ksi.ksi_addr = ? */ 39628cbb9b1SJustin Hibbits ksi.ksi_trapno = type; 39728cbb9b1SJustin Hibbits trapsignal(td, &ksi); 39828cbb9b1SJustin Hibbits } 39928cbb9b1SJustin Hibbits 40028cbb9b1SJustin Hibbits userret(td, frame); 40128cbb9b1SJustin Hibbits } 40228cbb9b1SJustin Hibbits 40328cbb9b1SJustin Hibbits static void 40428cbb9b1SJustin Hibbits trap_fatal(struct trapframe *frame) 40528cbb9b1SJustin Hibbits { 40628cbb9b1SJustin Hibbits 40728cbb9b1SJustin Hibbits printtrap(frame->exc, frame, 1, (frame->srr1 & PSL_PR)); 40828cbb9b1SJustin Hibbits #ifdef KDB 40928cbb9b1SJustin Hibbits if ((debugger_on_panic || kdb_active) && 41028cbb9b1SJustin Hibbits kdb_trap(frame->exc, 0, frame)) 41128cbb9b1SJustin Hibbits return; 41228cbb9b1SJustin Hibbits #endif 41328cbb9b1SJustin Hibbits panic("%s trap", trapname(frame->exc)); 41428cbb9b1SJustin Hibbits } 41528cbb9b1SJustin Hibbits 41628cbb9b1SJustin Hibbits static void 41728cbb9b1SJustin Hibbits printtrap(u_int vector, struct trapframe *frame, int isfatal, int user) 41828cbb9b1SJustin Hibbits { 419398973f8SJustin Hibbits uint16_t ver; 4206035018bSJustin Hibbits #ifdef BOOKE 4216035018bSJustin Hibbits vm_paddr_t pa; 4226035018bSJustin Hibbits #endif 42328cbb9b1SJustin Hibbits 42428cbb9b1SJustin Hibbits printf("\n"); 42528cbb9b1SJustin Hibbits printf("%s %s trap:\n", isfatal ? "fatal" : "handled", 42628cbb9b1SJustin Hibbits user ? "user" : "kernel"); 42728cbb9b1SJustin Hibbits printf("\n"); 42828cbb9b1SJustin Hibbits printf(" exception = 0x%x (%s)\n", vector, trapname(vector)); 42928cbb9b1SJustin Hibbits switch (vector) { 43028cbb9b1SJustin Hibbits case EXC_DSE: 43128cbb9b1SJustin Hibbits case EXC_DSI: 43239a4b70fSJustin Hibbits case EXC_DTMISS: 43328cbb9b1SJustin Hibbits printf(" virtual address = 0x%" PRIxPTR "\n", frame->dar); 43439a4b70fSJustin Hibbits #ifdef AIM 435cf5aa326SJustin Hibbits printf(" dsisr = 0x%lx\n", 436cf5aa326SJustin Hibbits (u_long)frame->cpu.aim.dsisr); 43739a4b70fSJustin Hibbits #endif 43828cbb9b1SJustin Hibbits break; 43928cbb9b1SJustin Hibbits case EXC_ISE: 44028cbb9b1SJustin Hibbits case EXC_ISI: 44139a4b70fSJustin Hibbits case EXC_ITMISS: 44228cbb9b1SJustin Hibbits printf(" virtual address = 0x%" PRIxPTR "\n", frame->srr0); 44328cbb9b1SJustin Hibbits break; 444398973f8SJustin Hibbits case EXC_MCHK: 445398973f8SJustin Hibbits ver = mfpvr() >> 16; 446398973f8SJustin Hibbits #if defined(AIM) 447398973f8SJustin Hibbits if (MPC745X_P(ver)) 44844027a83SJustin Hibbits printf(" msssr0 = 0x%lx\n", 44944027a83SJustin Hibbits (u_long)mfspr(SPR_MSSSR0)); 450398973f8SJustin Hibbits #elif defined(BOOKE) 4516035018bSJustin Hibbits pa = mfspr(SPR_MCARU); 45201a40173SJustin Hibbits pa = (pa << 32) | (u_register_t)mfspr(SPR_MCAR); 45344027a83SJustin Hibbits printf(" mcsr = 0x%lx\n", (u_long)mfspr(SPR_MCSR)); 4546035018bSJustin Hibbits printf(" mcar = 0x%jx\n", (uintmax_t)pa); 455398973f8SJustin Hibbits #endif 456398973f8SJustin Hibbits break; 45728cbb9b1SJustin Hibbits } 45839a4b70fSJustin Hibbits #ifdef BOOKE 45939a4b70fSJustin Hibbits printf(" esr = 0x%" PRIxPTR "\n", 46039a4b70fSJustin Hibbits frame->cpu.booke.esr); 46139a4b70fSJustin Hibbits #endif 46228cbb9b1SJustin Hibbits printf(" srr0 = 0x%" PRIxPTR "\n", frame->srr0); 463cf5aa326SJustin Hibbits printf(" srr1 = 0x%lx\n", (u_long)frame->srr1); 46428cbb9b1SJustin Hibbits printf(" lr = 0x%" PRIxPTR "\n", frame->lr); 46528cbb9b1SJustin Hibbits printf(" curthread = %p\n", curthread); 46628cbb9b1SJustin Hibbits if (curthread != NULL) 46728cbb9b1SJustin Hibbits printf(" pid = %d, comm = %s\n", 46828cbb9b1SJustin Hibbits curthread->td_proc->p_pid, curthread->td_name); 46928cbb9b1SJustin Hibbits printf("\n"); 47028cbb9b1SJustin Hibbits } 47128cbb9b1SJustin Hibbits 47228cbb9b1SJustin Hibbits /* 47328cbb9b1SJustin Hibbits * Handles a fatal fault when we have onfault state to recover. Returns 47428cbb9b1SJustin Hibbits * non-zero if there was onfault recovery state available. 47528cbb9b1SJustin Hibbits */ 47628cbb9b1SJustin Hibbits static int 47728cbb9b1SJustin Hibbits handle_onfault(struct trapframe *frame) 47828cbb9b1SJustin Hibbits { 47928cbb9b1SJustin Hibbits struct thread *td; 480a18c313eSNathan Whitehorn jmp_buf *fb; 48128cbb9b1SJustin Hibbits 48228cbb9b1SJustin Hibbits td = curthread; 48328cbb9b1SJustin Hibbits fb = td->td_pcb->pcb_onfault; 48428cbb9b1SJustin Hibbits if (fb != NULL) { 485a18c313eSNathan Whitehorn frame->srr0 = (*fb)->_jb[FAULTBUF_LR]; 486a18c313eSNathan Whitehorn frame->fixreg[1] = (*fb)->_jb[FAULTBUF_R1]; 487a18c313eSNathan Whitehorn frame->fixreg[2] = (*fb)->_jb[FAULTBUF_R2]; 48828cbb9b1SJustin Hibbits frame->fixreg[3] = 1; 489a18c313eSNathan Whitehorn frame->cr = (*fb)->_jb[FAULTBUF_CR]; 490a18c313eSNathan Whitehorn bcopy(&(*fb)->_jb[FAULTBUF_R14], &frame->fixreg[14], 491a18c313eSNathan Whitehorn 18 * sizeof(register_t)); 492a18c313eSNathan Whitehorn td->td_pcb->pcb_onfault = NULL; /* Returns twice, not thrice */ 49328cbb9b1SJustin Hibbits return (1); 49428cbb9b1SJustin Hibbits } 49528cbb9b1SJustin Hibbits return (0); 49628cbb9b1SJustin Hibbits } 49728cbb9b1SJustin Hibbits 49828cbb9b1SJustin Hibbits int 49928cbb9b1SJustin Hibbits cpu_fetch_syscall_args(struct thread *td, struct syscall_args *sa) 50028cbb9b1SJustin Hibbits { 50128cbb9b1SJustin Hibbits struct proc *p; 50228cbb9b1SJustin Hibbits struct trapframe *frame; 50328cbb9b1SJustin Hibbits caddr_t params; 50428cbb9b1SJustin Hibbits size_t argsz; 50528cbb9b1SJustin Hibbits int error, n, i; 50628cbb9b1SJustin Hibbits 50728cbb9b1SJustin Hibbits p = td->td_proc; 50828cbb9b1SJustin Hibbits frame = td->td_frame; 50928cbb9b1SJustin Hibbits 51028cbb9b1SJustin Hibbits sa->code = frame->fixreg[0]; 51128cbb9b1SJustin Hibbits params = (caddr_t)(frame->fixreg + FIRSTARG); 51228cbb9b1SJustin Hibbits n = NARGREG; 51328cbb9b1SJustin Hibbits 51428cbb9b1SJustin Hibbits if (sa->code == SYS_syscall) { 51528cbb9b1SJustin Hibbits /* 51628cbb9b1SJustin Hibbits * code is first argument, 51728cbb9b1SJustin Hibbits * followed by actual args. 51828cbb9b1SJustin Hibbits */ 51928cbb9b1SJustin Hibbits sa->code = *(register_t *) params; 52028cbb9b1SJustin Hibbits params += sizeof(register_t); 52128cbb9b1SJustin Hibbits n -= 1; 52228cbb9b1SJustin Hibbits } else if (sa->code == SYS___syscall) { 52328cbb9b1SJustin Hibbits /* 52428cbb9b1SJustin Hibbits * Like syscall, but code is a quad, 52528cbb9b1SJustin Hibbits * so as to maintain quad alignment 52628cbb9b1SJustin Hibbits * for the rest of the args. 52728cbb9b1SJustin Hibbits */ 52828cbb9b1SJustin Hibbits if (SV_PROC_FLAG(p, SV_ILP32)) { 52928cbb9b1SJustin Hibbits params += sizeof(register_t); 53028cbb9b1SJustin Hibbits sa->code = *(register_t *) params; 53128cbb9b1SJustin Hibbits params += sizeof(register_t); 53228cbb9b1SJustin Hibbits n -= 2; 53328cbb9b1SJustin Hibbits } else { 53428cbb9b1SJustin Hibbits sa->code = *(register_t *) params; 53528cbb9b1SJustin Hibbits params += sizeof(register_t); 53628cbb9b1SJustin Hibbits n -= 1; 53728cbb9b1SJustin Hibbits } 53828cbb9b1SJustin Hibbits } 53928cbb9b1SJustin Hibbits 54028cbb9b1SJustin Hibbits if (p->p_sysent->sv_mask) 54128cbb9b1SJustin Hibbits sa->code &= p->p_sysent->sv_mask; 54228cbb9b1SJustin Hibbits if (sa->code >= p->p_sysent->sv_size) 54328cbb9b1SJustin Hibbits sa->callp = &p->p_sysent->sv_table[0]; 54428cbb9b1SJustin Hibbits else 54528cbb9b1SJustin Hibbits sa->callp = &p->p_sysent->sv_table[sa->code]; 54628cbb9b1SJustin Hibbits 54728cbb9b1SJustin Hibbits sa->narg = sa->callp->sy_narg; 54828cbb9b1SJustin Hibbits 54928cbb9b1SJustin Hibbits if (SV_PROC_FLAG(p, SV_ILP32)) { 55028cbb9b1SJustin Hibbits argsz = sizeof(uint32_t); 55128cbb9b1SJustin Hibbits 55228cbb9b1SJustin Hibbits for (i = 0; i < n; i++) 55328cbb9b1SJustin Hibbits sa->args[i] = ((u_register_t *)(params))[i] & 55428cbb9b1SJustin Hibbits 0xffffffff; 55528cbb9b1SJustin Hibbits } else { 55628cbb9b1SJustin Hibbits argsz = sizeof(uint64_t); 55728cbb9b1SJustin Hibbits 55828cbb9b1SJustin Hibbits for (i = 0; i < n; i++) 55928cbb9b1SJustin Hibbits sa->args[i] = ((u_register_t *)(params))[i]; 56028cbb9b1SJustin Hibbits } 56128cbb9b1SJustin Hibbits 56228cbb9b1SJustin Hibbits if (sa->narg > n) 56328cbb9b1SJustin Hibbits error = copyin(MOREARGS(frame->fixreg[1]), sa->args + n, 56428cbb9b1SJustin Hibbits (sa->narg - n) * argsz); 56528cbb9b1SJustin Hibbits else 56628cbb9b1SJustin Hibbits error = 0; 56728cbb9b1SJustin Hibbits 56828cbb9b1SJustin Hibbits #ifdef __powerpc64__ 56928cbb9b1SJustin Hibbits if (SV_PROC_FLAG(p, SV_ILP32) && sa->narg > n) { 57028cbb9b1SJustin Hibbits /* Expand the size of arguments copied from the stack */ 57128cbb9b1SJustin Hibbits 57228cbb9b1SJustin Hibbits for (i = sa->narg; i >= n; i--) 57328cbb9b1SJustin Hibbits sa->args[i] = ((uint32_t *)(&sa->args[n]))[i-n]; 57428cbb9b1SJustin Hibbits } 57528cbb9b1SJustin Hibbits #endif 57628cbb9b1SJustin Hibbits 57728cbb9b1SJustin Hibbits if (error == 0) { 57828cbb9b1SJustin Hibbits td->td_retval[0] = 0; 57928cbb9b1SJustin Hibbits td->td_retval[1] = frame->fixreg[FIRSTARG + 1]; 58028cbb9b1SJustin Hibbits } 58128cbb9b1SJustin Hibbits return (error); 58228cbb9b1SJustin Hibbits } 58328cbb9b1SJustin Hibbits 58428cbb9b1SJustin Hibbits #include "../../kern/subr_syscall.c" 58528cbb9b1SJustin Hibbits 58628cbb9b1SJustin Hibbits void 58728cbb9b1SJustin Hibbits syscall(struct trapframe *frame) 58828cbb9b1SJustin Hibbits { 58928cbb9b1SJustin Hibbits struct thread *td; 59028cbb9b1SJustin Hibbits struct syscall_args sa; 59128cbb9b1SJustin Hibbits int error; 59228cbb9b1SJustin Hibbits 59328cbb9b1SJustin Hibbits td = curthread; 59428cbb9b1SJustin Hibbits td->td_frame = frame; 59528cbb9b1SJustin Hibbits 596d5a30121SJustin Hibbits #if defined(__powerpc64__) && defined(AIM) 59728cbb9b1SJustin Hibbits /* 59828cbb9b1SJustin Hibbits * Speculatively restore last user SLB segment, which we know is 59928cbb9b1SJustin Hibbits * invalid already, since we are likely to do copyin()/copyout(). 60028cbb9b1SJustin Hibbits */ 60128cbb9b1SJustin Hibbits __asm __volatile ("slbmte %0, %1; isync" :: 60228cbb9b1SJustin Hibbits "r"(td->td_pcb->pcb_cpu.aim.usr_vsid), "r"(USER_SLB_SLBE)); 60328cbb9b1SJustin Hibbits #endif 60428cbb9b1SJustin Hibbits 60528cbb9b1SJustin Hibbits error = syscallenter(td, &sa); 60628cbb9b1SJustin Hibbits syscallret(td, error, &sa); 60728cbb9b1SJustin Hibbits } 60828cbb9b1SJustin Hibbits 609d5a30121SJustin Hibbits #if defined(__powerpc64__) && defined(AIM) 61028cbb9b1SJustin Hibbits /* Handle kernel SLB faults -- runs in real mode, all seat belts off */ 61128cbb9b1SJustin Hibbits void 61228cbb9b1SJustin Hibbits handle_kernel_slb_spill(int type, register_t dar, register_t srr0) 61328cbb9b1SJustin Hibbits { 61428cbb9b1SJustin Hibbits struct slb *slbcache; 61528cbb9b1SJustin Hibbits uint64_t slbe, slbv; 61628cbb9b1SJustin Hibbits uint64_t esid, addr; 61728cbb9b1SJustin Hibbits int i; 61828cbb9b1SJustin Hibbits 61928cbb9b1SJustin Hibbits addr = (type == EXC_ISE) ? srr0 : dar; 62028cbb9b1SJustin Hibbits slbcache = PCPU_GET(slb); 62128cbb9b1SJustin Hibbits esid = (uintptr_t)addr >> ADDR_SR_SHFT; 62228cbb9b1SJustin Hibbits slbe = (esid << SLBE_ESID_SHIFT) | SLBE_VALID; 62328cbb9b1SJustin Hibbits 62428cbb9b1SJustin Hibbits /* See if the hardware flushed this somehow (can happen in LPARs) */ 62528cbb9b1SJustin Hibbits for (i = 0; i < n_slbs; i++) 62628cbb9b1SJustin Hibbits if (slbcache[i].slbe == (slbe | (uint64_t)i)) 62728cbb9b1SJustin Hibbits return; 62828cbb9b1SJustin Hibbits 62928cbb9b1SJustin Hibbits /* Not in the map, needs to actually be added */ 63028cbb9b1SJustin Hibbits slbv = kernel_va_to_slbv(addr); 63128cbb9b1SJustin Hibbits if (slbcache[USER_SLB_SLOT].slbe == 0) { 63228cbb9b1SJustin Hibbits for (i = 0; i < n_slbs; i++) { 63328cbb9b1SJustin Hibbits if (i == USER_SLB_SLOT) 63428cbb9b1SJustin Hibbits continue; 63528cbb9b1SJustin Hibbits if (!(slbcache[i].slbe & SLBE_VALID)) 63628cbb9b1SJustin Hibbits goto fillkernslb; 63728cbb9b1SJustin Hibbits } 63828cbb9b1SJustin Hibbits 63928cbb9b1SJustin Hibbits if (i == n_slbs) 64028cbb9b1SJustin Hibbits slbcache[USER_SLB_SLOT].slbe = 1; 64128cbb9b1SJustin Hibbits } 64228cbb9b1SJustin Hibbits 64328cbb9b1SJustin Hibbits /* Sacrifice a random SLB entry that is not the user entry */ 64428cbb9b1SJustin Hibbits i = mftb() % n_slbs; 64528cbb9b1SJustin Hibbits if (i == USER_SLB_SLOT) 64628cbb9b1SJustin Hibbits i = (i+1) % n_slbs; 64728cbb9b1SJustin Hibbits 64828cbb9b1SJustin Hibbits fillkernslb: 64928cbb9b1SJustin Hibbits /* Write new entry */ 65028cbb9b1SJustin Hibbits slbcache[i].slbv = slbv; 65128cbb9b1SJustin Hibbits slbcache[i].slbe = slbe | (uint64_t)i; 65228cbb9b1SJustin Hibbits 65328cbb9b1SJustin Hibbits /* Trap handler will restore from cache on exit */ 65428cbb9b1SJustin Hibbits } 65528cbb9b1SJustin Hibbits 65628cbb9b1SJustin Hibbits static int 65728cbb9b1SJustin Hibbits handle_user_slb_spill(pmap_t pm, vm_offset_t addr) 65828cbb9b1SJustin Hibbits { 65928cbb9b1SJustin Hibbits struct slb *user_entry; 66028cbb9b1SJustin Hibbits uint64_t esid; 66128cbb9b1SJustin Hibbits int i; 66228cbb9b1SJustin Hibbits 66328cbb9b1SJustin Hibbits esid = (uintptr_t)addr >> ADDR_SR_SHFT; 66428cbb9b1SJustin Hibbits 66528cbb9b1SJustin Hibbits PMAP_LOCK(pm); 66628cbb9b1SJustin Hibbits user_entry = user_va_to_slb_entry(pm, addr); 66728cbb9b1SJustin Hibbits 66828cbb9b1SJustin Hibbits if (user_entry == NULL) { 66928cbb9b1SJustin Hibbits /* allocate_vsid auto-spills it */ 67028cbb9b1SJustin Hibbits (void)allocate_user_vsid(pm, esid, 0); 67128cbb9b1SJustin Hibbits } else { 67228cbb9b1SJustin Hibbits /* 67328cbb9b1SJustin Hibbits * Check that another CPU has not already mapped this. 67428cbb9b1SJustin Hibbits * XXX: Per-thread SLB caches would be better. 67528cbb9b1SJustin Hibbits */ 67628cbb9b1SJustin Hibbits for (i = 0; i < pm->pm_slb_len; i++) 67728cbb9b1SJustin Hibbits if (pm->pm_slb[i] == user_entry) 67828cbb9b1SJustin Hibbits break; 67928cbb9b1SJustin Hibbits 68028cbb9b1SJustin Hibbits if (i == pm->pm_slb_len) 68128cbb9b1SJustin Hibbits slb_insert_user(pm, user_entry); 68228cbb9b1SJustin Hibbits } 68328cbb9b1SJustin Hibbits PMAP_UNLOCK(pm); 68428cbb9b1SJustin Hibbits 68528cbb9b1SJustin Hibbits return (0); 68628cbb9b1SJustin Hibbits } 68728cbb9b1SJustin Hibbits #endif 68828cbb9b1SJustin Hibbits 68928cbb9b1SJustin Hibbits static int 69028cbb9b1SJustin Hibbits trap_pfault(struct trapframe *frame, int user) 69128cbb9b1SJustin Hibbits { 69228cbb9b1SJustin Hibbits vm_offset_t eva, va; 69328cbb9b1SJustin Hibbits struct thread *td; 69428cbb9b1SJustin Hibbits struct proc *p; 69528cbb9b1SJustin Hibbits vm_map_t map; 69628cbb9b1SJustin Hibbits vm_prot_t ftype; 69728cbb9b1SJustin Hibbits int rv; 69828cbb9b1SJustin Hibbits #ifdef AIM 69928cbb9b1SJustin Hibbits register_t user_sr; 70028cbb9b1SJustin Hibbits #endif 70128cbb9b1SJustin Hibbits 70228cbb9b1SJustin Hibbits td = curthread; 70328cbb9b1SJustin Hibbits p = td->td_proc; 70428cbb9b1SJustin Hibbits if (frame->exc == EXC_ISI) { 70528cbb9b1SJustin Hibbits eva = frame->srr0; 70628cbb9b1SJustin Hibbits ftype = VM_PROT_EXECUTE; 70728cbb9b1SJustin Hibbits if (frame->srr1 & SRR1_ISI_PFAULT) 70828cbb9b1SJustin Hibbits ftype |= VM_PROT_READ; 70928cbb9b1SJustin Hibbits } else { 71028cbb9b1SJustin Hibbits eva = frame->dar; 71128cbb9b1SJustin Hibbits #ifdef BOOKE 71228cbb9b1SJustin Hibbits if (frame->cpu.booke.esr & ESR_ST) 71328cbb9b1SJustin Hibbits #else 71428cbb9b1SJustin Hibbits if (frame->cpu.aim.dsisr & DSISR_STORE) 71528cbb9b1SJustin Hibbits #endif 71628cbb9b1SJustin Hibbits ftype = VM_PROT_WRITE; 71728cbb9b1SJustin Hibbits else 71828cbb9b1SJustin Hibbits ftype = VM_PROT_READ; 71928cbb9b1SJustin Hibbits } 72028cbb9b1SJustin Hibbits 72128cbb9b1SJustin Hibbits if (user) { 72228cbb9b1SJustin Hibbits KASSERT(p->p_vmspace != NULL, ("trap_pfault: vmspace NULL")); 72328cbb9b1SJustin Hibbits map = &p->p_vmspace->vm_map; 72428cbb9b1SJustin Hibbits } else { 72528cbb9b1SJustin Hibbits #ifdef BOOKE 72628cbb9b1SJustin Hibbits if (eva < VM_MAXUSER_ADDRESS) { 72728cbb9b1SJustin Hibbits #else 72828cbb9b1SJustin Hibbits if ((eva >> ADDR_SR_SHFT) == (USER_ADDR >> ADDR_SR_SHFT)) { 72928cbb9b1SJustin Hibbits #endif 73028cbb9b1SJustin Hibbits map = &p->p_vmspace->vm_map; 73128cbb9b1SJustin Hibbits 73228cbb9b1SJustin Hibbits #ifdef AIM 73328cbb9b1SJustin Hibbits user_sr = td->td_pcb->pcb_cpu.aim.usr_segm; 73428cbb9b1SJustin Hibbits eva &= ADDR_PIDX | ADDR_POFF; 73528cbb9b1SJustin Hibbits eva |= user_sr << ADDR_SR_SHFT; 73628cbb9b1SJustin Hibbits #endif 73728cbb9b1SJustin Hibbits } else { 73828cbb9b1SJustin Hibbits map = kernel_map; 73928cbb9b1SJustin Hibbits } 74028cbb9b1SJustin Hibbits } 74128cbb9b1SJustin Hibbits va = trunc_page(eva); 74228cbb9b1SJustin Hibbits 7431fa67124SKonstantin Belousov /* Fault in the page. */ 74428cbb9b1SJustin Hibbits rv = vm_fault(map, va, ftype, VM_FAULT_NORMAL); 74528cbb9b1SJustin Hibbits /* 74628cbb9b1SJustin Hibbits * XXXDTRACE: add dtrace_doubletrap_func here? 74728cbb9b1SJustin Hibbits */ 74828cbb9b1SJustin Hibbits 74928cbb9b1SJustin Hibbits if (rv == KERN_SUCCESS) 75028cbb9b1SJustin Hibbits return (0); 75128cbb9b1SJustin Hibbits 75228cbb9b1SJustin Hibbits if (!user && handle_onfault(frame)) 75328cbb9b1SJustin Hibbits return (0); 75428cbb9b1SJustin Hibbits 75528cbb9b1SJustin Hibbits return (SIGSEGV); 75628cbb9b1SJustin Hibbits } 75728cbb9b1SJustin Hibbits 75828cbb9b1SJustin Hibbits /* 75928cbb9b1SJustin Hibbits * For now, this only deals with the particular unaligned access case 76028cbb9b1SJustin Hibbits * that gcc tends to generate. Eventually it should handle all of the 76128cbb9b1SJustin Hibbits * possibilities that can happen on a 32-bit PowerPC in big-endian mode. 76228cbb9b1SJustin Hibbits */ 76328cbb9b1SJustin Hibbits 76428cbb9b1SJustin Hibbits static int 76528cbb9b1SJustin Hibbits fix_unaligned(struct thread *td, struct trapframe *frame) 76628cbb9b1SJustin Hibbits { 76728cbb9b1SJustin Hibbits struct thread *fputhread; 768dc9b124dSJustin Hibbits #ifdef __SPE__ 769dc9b124dSJustin Hibbits uint32_t inst; 770dc9b124dSJustin Hibbits #endif 77128cbb9b1SJustin Hibbits int indicator, reg; 77228cbb9b1SJustin Hibbits double *fpr; 77328cbb9b1SJustin Hibbits 774dc9b124dSJustin Hibbits #ifdef __SPE__ 775dc9b124dSJustin Hibbits indicator = (frame->cpu.booke.esr & (ESR_ST|ESR_SPE)); 776dc9b124dSJustin Hibbits if (indicator & ESR_SPE) { 777dc9b124dSJustin Hibbits if (copyin((void *)frame->srr0, &inst, sizeof(inst)) != 0) 778dc9b124dSJustin Hibbits return (-1); 779dc9b124dSJustin Hibbits reg = EXC_ALI_SPE_REG(inst); 780dc9b124dSJustin Hibbits fpr = (double *)td->td_pcb->pcb_vec.vr[reg]; 781dc9b124dSJustin Hibbits fputhread = PCPU_GET(vecthread); 782dc9b124dSJustin Hibbits 78389965e70SJustin Hibbits /* Juggle the SPE to ensure that we've initialized 78489965e70SJustin Hibbits * the registers, and that their current state is in 785dc9b124dSJustin Hibbits * the PCB. 786dc9b124dSJustin Hibbits */ 787eaa5e396SJustin Hibbits if (fputhread != td) { 788eaa5e396SJustin Hibbits if (fputhread) 789eaa5e396SJustin Hibbits save_vec(fputhread); 790dc9b124dSJustin Hibbits enable_vec(td); 791dc9b124dSJustin Hibbits } 792dc9b124dSJustin Hibbits save_vec(td); 793dc9b124dSJustin Hibbits 794dc9b124dSJustin Hibbits if (!(indicator & ESR_ST)) { 795dc9b124dSJustin Hibbits if (copyin((void *)frame->dar, fpr, 796dc9b124dSJustin Hibbits sizeof(double)) != 0) 797dc9b124dSJustin Hibbits return (-1); 798dc9b124dSJustin Hibbits frame->fixreg[reg] = td->td_pcb->pcb_vec.vr[reg][1]; 799dc9b124dSJustin Hibbits enable_vec(td); 800dc9b124dSJustin Hibbits } else { 801dc9b124dSJustin Hibbits td->td_pcb->pcb_vec.vr[reg][1] = frame->fixreg[reg]; 802dc9b124dSJustin Hibbits if (copyout(fpr, (void *)frame->dar, 803dc9b124dSJustin Hibbits sizeof(double)) != 0) 804dc9b124dSJustin Hibbits return (-1); 805dc9b124dSJustin Hibbits } 806dc9b124dSJustin Hibbits return (0); 807dc9b124dSJustin Hibbits } 808dc9b124dSJustin Hibbits #else 80928cbb9b1SJustin Hibbits indicator = EXC_ALI_OPCODE_INDICATOR(frame->cpu.aim.dsisr); 81028cbb9b1SJustin Hibbits 81128cbb9b1SJustin Hibbits switch (indicator) { 81228cbb9b1SJustin Hibbits case EXC_ALI_LFD: 81328cbb9b1SJustin Hibbits case EXC_ALI_STFD: 81428cbb9b1SJustin Hibbits reg = EXC_ALI_RST(frame->cpu.aim.dsisr); 81528cbb9b1SJustin Hibbits fpr = &td->td_pcb->pcb_fpu.fpr[reg].fpr; 81628cbb9b1SJustin Hibbits fputhread = PCPU_GET(fputhread); 81728cbb9b1SJustin Hibbits 81828cbb9b1SJustin Hibbits /* Juggle the FPU to ensure that we've initialized 81928cbb9b1SJustin Hibbits * the FPRs, and that their current state is in 82028cbb9b1SJustin Hibbits * the PCB. 82128cbb9b1SJustin Hibbits */ 82228cbb9b1SJustin Hibbits if (fputhread != td) { 82328cbb9b1SJustin Hibbits if (fputhread) 82428cbb9b1SJustin Hibbits save_fpu(fputhread); 82528cbb9b1SJustin Hibbits enable_fpu(td); 82628cbb9b1SJustin Hibbits } 82728cbb9b1SJustin Hibbits save_fpu(td); 82828cbb9b1SJustin Hibbits 82928cbb9b1SJustin Hibbits if (indicator == EXC_ALI_LFD) { 83028cbb9b1SJustin Hibbits if (copyin((void *)frame->dar, fpr, 83128cbb9b1SJustin Hibbits sizeof(double)) != 0) 83228cbb9b1SJustin Hibbits return (-1); 83328cbb9b1SJustin Hibbits enable_fpu(td); 83428cbb9b1SJustin Hibbits } else { 83528cbb9b1SJustin Hibbits if (copyout(fpr, (void *)frame->dar, 83628cbb9b1SJustin Hibbits sizeof(double)) != 0) 83728cbb9b1SJustin Hibbits return (-1); 83828cbb9b1SJustin Hibbits } 83928cbb9b1SJustin Hibbits return (0); 84028cbb9b1SJustin Hibbits break; 84128cbb9b1SJustin Hibbits } 842dc9b124dSJustin Hibbits #endif 84328cbb9b1SJustin Hibbits 84428cbb9b1SJustin Hibbits return (-1); 84528cbb9b1SJustin Hibbits } 84628cbb9b1SJustin Hibbits 84728cbb9b1SJustin Hibbits #ifdef KDB 84828cbb9b1SJustin Hibbits int 84928cbb9b1SJustin Hibbits db_trap_glue(struct trapframe *frame) 85028cbb9b1SJustin Hibbits { 85115fc4ab7SJustin Hibbits 85228cbb9b1SJustin Hibbits if (!(frame->srr1 & PSL_PR) 85328cbb9b1SJustin Hibbits && (frame->exc == EXC_TRC || frame->exc == EXC_RUNMODETRC 854e3e38bc7SJustin Hibbits #ifdef AIM 85528cbb9b1SJustin Hibbits || (frame->exc == EXC_PGM 8567a67c1f8SJustin Hibbits && (frame->srr1 & EXC_PGM_TRAP)) 857e3e38bc7SJustin Hibbits #else 858e3e38bc7SJustin Hibbits || (frame->exc == EXC_DEBUG) 85915fc4ab7SJustin Hibbits || (frame->cpu.booke.esr & ESR_PTR) 860e3e38bc7SJustin Hibbits #endif 86128cbb9b1SJustin Hibbits || frame->exc == EXC_BPT 86228cbb9b1SJustin Hibbits || frame->exc == EXC_DSI)) { 86328cbb9b1SJustin Hibbits int type = frame->exc; 86428cbb9b1SJustin Hibbits 86528cbb9b1SJustin Hibbits /* Ignore DTrace traps. */ 86628cbb9b1SJustin Hibbits if (*(uint32_t *)frame->srr0 == EXC_DTRACE) 86728cbb9b1SJustin Hibbits return (0); 868e3e38bc7SJustin Hibbits #ifdef AIM 8697a67c1f8SJustin Hibbits if (type == EXC_PGM && (frame->srr1 & EXC_PGM_TRAP)) { 870e3e38bc7SJustin Hibbits #else 87115fc4ab7SJustin Hibbits if (type == EXC_DEBUG || 87215fc4ab7SJustin Hibbits (frame->cpu.booke.esr & ESR_PTR)) { 873e3e38bc7SJustin Hibbits #endif 87428cbb9b1SJustin Hibbits type = T_BREAKPOINT; 87528cbb9b1SJustin Hibbits } 87628cbb9b1SJustin Hibbits return (kdb_trap(type, 0, frame)); 87728cbb9b1SJustin Hibbits } 87828cbb9b1SJustin Hibbits 87928cbb9b1SJustin Hibbits return (0); 88028cbb9b1SJustin Hibbits } 88128cbb9b1SJustin Hibbits #endif 882