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 100ec75f647SNathan Whitehorn extern vm_offset_t __startkernel; 101ec75f647SNathan Whitehorn 10215fc4ab7SJustin Hibbits #ifdef KDB 10315fc4ab7SJustin Hibbits int db_trap_glue(struct trapframe *); /* Called from trap_subr.S */ 10415fc4ab7SJustin Hibbits #endif 10515fc4ab7SJustin Hibbits 10628cbb9b1SJustin Hibbits struct powerpc_exception { 10728cbb9b1SJustin Hibbits u_int vector; 10828cbb9b1SJustin Hibbits char *name; 10928cbb9b1SJustin Hibbits }; 11028cbb9b1SJustin Hibbits 11128cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS 11228cbb9b1SJustin Hibbits #include <sys/dtrace_bsd.h> 11328cbb9b1SJustin Hibbits 11428cbb9b1SJustin Hibbits int (*dtrace_invop_jump_addr)(struct trapframe *); 11528cbb9b1SJustin Hibbits #endif 11628cbb9b1SJustin Hibbits 11728cbb9b1SJustin Hibbits static struct powerpc_exception powerpc_exceptions[] = { 11828cbb9b1SJustin Hibbits { EXC_CRIT, "critical input" }, 11928cbb9b1SJustin Hibbits { EXC_RST, "system reset" }, 12028cbb9b1SJustin Hibbits { EXC_MCHK, "machine check" }, 12128cbb9b1SJustin Hibbits { EXC_DSI, "data storage interrupt" }, 12228cbb9b1SJustin Hibbits { EXC_DSE, "data segment exception" }, 12328cbb9b1SJustin Hibbits { EXC_ISI, "instruction storage interrupt" }, 12428cbb9b1SJustin Hibbits { EXC_ISE, "instruction segment exception" }, 12528cbb9b1SJustin Hibbits { EXC_EXI, "external interrupt" }, 12628cbb9b1SJustin Hibbits { EXC_ALI, "alignment" }, 12728cbb9b1SJustin Hibbits { EXC_PGM, "program" }, 128ec75f647SNathan Whitehorn { EXC_HEA, "hypervisor emulation assistance" }, 12928cbb9b1SJustin Hibbits { EXC_FPU, "floating-point unavailable" }, 13028cbb9b1SJustin Hibbits { EXC_APU, "auxiliary proc unavailable" }, 13128cbb9b1SJustin Hibbits { EXC_DECR, "decrementer" }, 13228cbb9b1SJustin Hibbits { EXC_FIT, "fixed-interval timer" }, 13328cbb9b1SJustin Hibbits { EXC_WDOG, "watchdog timer" }, 13428cbb9b1SJustin Hibbits { EXC_SC, "system call" }, 13528cbb9b1SJustin Hibbits { EXC_TRC, "trace" }, 13628cbb9b1SJustin Hibbits { EXC_FPA, "floating-point assist" }, 13728cbb9b1SJustin Hibbits { EXC_DEBUG, "debug" }, 13828cbb9b1SJustin Hibbits { EXC_PERF, "performance monitoring" }, 13928cbb9b1SJustin Hibbits { EXC_VEC, "altivec unavailable" }, 14028cbb9b1SJustin Hibbits { EXC_VSX, "vsx unavailable" }, 1417cd4e55cSJustin Hibbits { EXC_FAC, "facility unavailable" }, 14228cbb9b1SJustin Hibbits { EXC_ITMISS, "instruction tlb miss" }, 14328cbb9b1SJustin Hibbits { EXC_DLMISS, "data load tlb miss" }, 14428cbb9b1SJustin Hibbits { EXC_DSMISS, "data store tlb miss" }, 14528cbb9b1SJustin Hibbits { EXC_BPT, "instruction breakpoint" }, 14628cbb9b1SJustin Hibbits { EXC_SMI, "system management" }, 14728cbb9b1SJustin Hibbits { EXC_VECAST_G4, "altivec assist" }, 14828cbb9b1SJustin Hibbits { EXC_THRM, "thermal management" }, 14928cbb9b1SJustin Hibbits { EXC_RUNMODETRC, "run mode/trace" }, 15028cbb9b1SJustin Hibbits { EXC_LAST, NULL } 15128cbb9b1SJustin Hibbits }; 15228cbb9b1SJustin Hibbits 153bf1b9296SJustin Hibbits #define ESR_BITMASK \ 154bf1b9296SJustin Hibbits "\20" \ 155bf1b9296SJustin Hibbits "\040b0\037b1\036b2\035b3\034PIL\033PRR\032PTR\031FP" \ 156bf1b9296SJustin Hibbits "\030ST\027b9\026DLK\025ILK\024b12\023b13\022BO\021PIE" \ 157bf1b9296SJustin Hibbits "\020b16\017b17\016b18\015b19\014b20\013b21\012b22\011b23" \ 158bf1b9296SJustin Hibbits "\010SPE\007EPID\006b26\005b27\004b28\003b29\002b30\001b31" 159bf1b9296SJustin Hibbits #define MCSR_BITMASK \ 160bf1b9296SJustin Hibbits "\20" \ 161bf1b9296SJustin Hibbits "\040MCP\037ICERR\036DCERR\035TLBPERR\034L2MMU_MHIT\033b5\032b6\031b7" \ 162bf1b9296SJustin Hibbits "\030b8\027b9\026b10\025NMI\024MAV\023MEA\022b14\021IF" \ 163bf1b9296SJustin Hibbits "\020LD\017ST\016LDG\015b19\014b20\013b21\012b22\011b23" \ 164bf1b9296SJustin Hibbits "\010b24\007b25\006b26\005b27\004b28\003b29\002TLBSYNC\001BSL2_ERR" 165bf1b9296SJustin Hibbits #define MSSSR_BITMASK \ 166bf1b9296SJustin Hibbits "\20" \ 167bf1b9296SJustin Hibbits "\040b0\037b1\036b2\035b3\034b4\033b5\032b6\031b7" \ 168bf1b9296SJustin Hibbits "\030b8\027b9\026b10\025b11\024b12\023L2TAG\022L2DAT\021L3TAG" \ 169bf1b9296SJustin Hibbits "\020L3DAT\017APE\016DPE\015TEA\014b20\013b21\012b22\011b23" \ 170bf1b9296SJustin Hibbits "\010b24\007b25\006b26\005b27\004b28\003b29\002b30\001b31" 171bf1b9296SJustin Hibbits 172bf1b9296SJustin Hibbits 17328cbb9b1SJustin Hibbits static const char * 17428cbb9b1SJustin Hibbits trapname(u_int vector) 17528cbb9b1SJustin Hibbits { 17628cbb9b1SJustin Hibbits struct powerpc_exception *pe; 17728cbb9b1SJustin Hibbits 17828cbb9b1SJustin Hibbits for (pe = powerpc_exceptions; pe->vector != EXC_LAST; pe++) { 17928cbb9b1SJustin Hibbits if (pe->vector == vector) 18028cbb9b1SJustin Hibbits return (pe->name); 18128cbb9b1SJustin Hibbits } 18228cbb9b1SJustin Hibbits 18328cbb9b1SJustin Hibbits return ("unknown"); 18428cbb9b1SJustin Hibbits } 18528cbb9b1SJustin Hibbits 186a72b9513SJustin Hibbits static inline bool 187a72b9513SJustin Hibbits frame_is_trap_inst(struct trapframe *frame) 188a72b9513SJustin Hibbits { 189a72b9513SJustin Hibbits #ifdef AIM 190a72b9513SJustin Hibbits return (frame->exc == EXC_PGM && frame->srr1 & EXC_PGM_TRAP); 191a72b9513SJustin Hibbits #else 192a72b9513SJustin Hibbits return (frame->exc == EXC_DEBUG || frame->cpu.booke.esr & ESR_PTR); 193a72b9513SJustin Hibbits #endif 194a72b9513SJustin Hibbits } 195a72b9513SJustin Hibbits 19628cbb9b1SJustin Hibbits void 19728cbb9b1SJustin Hibbits trap(struct trapframe *frame) 19828cbb9b1SJustin Hibbits { 19928cbb9b1SJustin Hibbits struct thread *td; 20028cbb9b1SJustin Hibbits struct proc *p; 20128cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS 20228cbb9b1SJustin Hibbits uint32_t inst; 20328cbb9b1SJustin Hibbits #endif 20428cbb9b1SJustin Hibbits int sig, type, user; 20528cbb9b1SJustin Hibbits u_int ucode; 20628cbb9b1SJustin Hibbits ksiginfo_t ksi; 20728cbb9b1SJustin Hibbits 20883c9dea1SGleb Smirnoff VM_CNT_INC(v_trap); 20928cbb9b1SJustin Hibbits 21028cbb9b1SJustin Hibbits td = curthread; 21128cbb9b1SJustin Hibbits p = td->td_proc; 21228cbb9b1SJustin Hibbits 21328cbb9b1SJustin Hibbits type = ucode = frame->exc; 21428cbb9b1SJustin Hibbits sig = 0; 21528cbb9b1SJustin Hibbits user = frame->srr1 & PSL_PR; 21628cbb9b1SJustin Hibbits 21728cbb9b1SJustin Hibbits CTR3(KTR_TRAP, "trap: %s type=%s (%s)", td->td_name, 21828cbb9b1SJustin Hibbits trapname(type), user ? "user" : "kernel"); 21928cbb9b1SJustin Hibbits 22028cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS 22128cbb9b1SJustin Hibbits /* 22228cbb9b1SJustin Hibbits * A trap can occur while DTrace executes a probe. Before 22328cbb9b1SJustin Hibbits * executing the probe, DTrace blocks re-scheduling and sets 22428cbb9b1SJustin Hibbits * a flag in its per-cpu flags to indicate that it doesn't 22528cbb9b1SJustin Hibbits * want to fault. On returning from the probe, the no-fault 22628cbb9b1SJustin Hibbits * flag is cleared and finally re-scheduling is enabled. 22728cbb9b1SJustin Hibbits * 22828cbb9b1SJustin Hibbits * If the DTrace kernel module has registered a trap handler, 22928cbb9b1SJustin Hibbits * call it and if it returns non-zero, assume that it has 23028cbb9b1SJustin Hibbits * handled the trap and modified the trap frame so that this 23128cbb9b1SJustin Hibbits * function can return normally. 23228cbb9b1SJustin Hibbits */ 23328cbb9b1SJustin Hibbits if (dtrace_trap_func != NULL && (*dtrace_trap_func)(frame, type) != 0) 23428cbb9b1SJustin Hibbits return; 23528cbb9b1SJustin Hibbits #endif 23628cbb9b1SJustin Hibbits 23728cbb9b1SJustin Hibbits if (user) { 23828cbb9b1SJustin Hibbits td->td_pticks = 0; 23928cbb9b1SJustin Hibbits td->td_frame = frame; 2404ea6a9a2SMateusz Guzik if (td->td_cowgen != p->p_cowgen) 2414ea6a9a2SMateusz Guzik thread_cow_update(td); 24228cbb9b1SJustin Hibbits 24328cbb9b1SJustin Hibbits /* User Mode Traps */ 24428cbb9b1SJustin Hibbits switch (type) { 24528cbb9b1SJustin Hibbits case EXC_RUNMODETRC: 24628cbb9b1SJustin Hibbits case EXC_TRC: 24728cbb9b1SJustin Hibbits frame->srr1 &= ~PSL_SE; 24828cbb9b1SJustin Hibbits sig = SIGTRAP; 24928cbb9b1SJustin Hibbits ucode = TRAP_TRACE; 25028cbb9b1SJustin Hibbits break; 25128cbb9b1SJustin Hibbits 252d5a30121SJustin Hibbits #if defined(__powerpc64__) && defined(AIM) 25328cbb9b1SJustin Hibbits case EXC_ISE: 25428cbb9b1SJustin Hibbits case EXC_DSE: 25528cbb9b1SJustin Hibbits if (handle_user_slb_spill(&p->p_vmspace->vm_pmap, 25628cbb9b1SJustin Hibbits (type == EXC_ISE) ? frame->srr0 : frame->dar) != 0){ 25728cbb9b1SJustin Hibbits sig = SIGSEGV; 25828cbb9b1SJustin Hibbits ucode = SEGV_MAPERR; 25928cbb9b1SJustin Hibbits } 26028cbb9b1SJustin Hibbits break; 26128cbb9b1SJustin Hibbits #endif 26228cbb9b1SJustin Hibbits case EXC_DSI: 26328cbb9b1SJustin Hibbits case EXC_ISI: 26428cbb9b1SJustin Hibbits sig = trap_pfault(frame, 1); 26528cbb9b1SJustin Hibbits if (sig == SIGSEGV) 26628cbb9b1SJustin Hibbits ucode = SEGV_MAPERR; 26728cbb9b1SJustin Hibbits break; 26828cbb9b1SJustin Hibbits 26928cbb9b1SJustin Hibbits case EXC_SC: 27028cbb9b1SJustin Hibbits syscall(frame); 27128cbb9b1SJustin Hibbits break; 27228cbb9b1SJustin Hibbits 27328cbb9b1SJustin Hibbits case EXC_FPU: 27428cbb9b1SJustin Hibbits KASSERT((td->td_pcb->pcb_flags & PCB_FPU) != PCB_FPU, 27528cbb9b1SJustin Hibbits ("FPU already enabled for thread")); 27628cbb9b1SJustin Hibbits enable_fpu(td); 27728cbb9b1SJustin Hibbits break; 27828cbb9b1SJustin Hibbits 27928cbb9b1SJustin Hibbits case EXC_VEC: 28028cbb9b1SJustin Hibbits KASSERT((td->td_pcb->pcb_flags & PCB_VEC) != PCB_VEC, 28128cbb9b1SJustin Hibbits ("Altivec already enabled for thread")); 28228cbb9b1SJustin Hibbits enable_vec(td); 28328cbb9b1SJustin Hibbits break; 28428cbb9b1SJustin Hibbits 28528cbb9b1SJustin Hibbits case EXC_VSX: 28628cbb9b1SJustin Hibbits KASSERT((td->td_pcb->pcb_flags & PCB_VSX) != PCB_VSX, 28728cbb9b1SJustin Hibbits ("VSX already enabled for thread")); 28828cbb9b1SJustin Hibbits if (!(td->td_pcb->pcb_flags & PCB_VEC)) 28928cbb9b1SJustin Hibbits enable_vec(td); 29028cbb9b1SJustin Hibbits if (!(td->td_pcb->pcb_flags & PCB_FPU)) 29128cbb9b1SJustin Hibbits save_fpu(td); 29228cbb9b1SJustin Hibbits td->td_pcb->pcb_flags |= PCB_VSX; 29328cbb9b1SJustin Hibbits enable_fpu(td); 29428cbb9b1SJustin Hibbits break; 29528cbb9b1SJustin Hibbits 2967cd4e55cSJustin Hibbits case EXC_FAC: 2977cd4e55cSJustin Hibbits sig = SIGILL; 2987cd4e55cSJustin Hibbits ucode = ILL_ILLOPC; 2997cd4e55cSJustin Hibbits break; 3007cd4e55cSJustin Hibbits 301541c5806SJustin Hibbits case EXC_VECAST_E: 30228cbb9b1SJustin Hibbits case EXC_VECAST_G4: 30328cbb9b1SJustin Hibbits case EXC_VECAST_G5: 30428cbb9b1SJustin Hibbits /* 30528cbb9b1SJustin Hibbits * We get a VPU assist exception for IEEE mode 30628cbb9b1SJustin Hibbits * vector operations on denormalized floats. 30728cbb9b1SJustin Hibbits * Emulating this is a giant pain, so for now, 30828cbb9b1SJustin Hibbits * just switch off IEEE mode and treat them as 30928cbb9b1SJustin Hibbits * zero. 31028cbb9b1SJustin Hibbits */ 31128cbb9b1SJustin Hibbits 31228cbb9b1SJustin Hibbits save_vec(td); 31328cbb9b1SJustin Hibbits td->td_pcb->pcb_vec.vscr |= ALTIVEC_VSCR_NJ; 31428cbb9b1SJustin Hibbits enable_vec(td); 31528cbb9b1SJustin Hibbits break; 31628cbb9b1SJustin Hibbits 31728cbb9b1SJustin Hibbits case EXC_ALI: 31828cbb9b1SJustin Hibbits if (fix_unaligned(td, frame) != 0) { 31928cbb9b1SJustin Hibbits sig = SIGBUS; 32028cbb9b1SJustin Hibbits ucode = BUS_ADRALN; 32128cbb9b1SJustin Hibbits } 32228cbb9b1SJustin Hibbits else 32328cbb9b1SJustin Hibbits frame->srr0 += 4; 32428cbb9b1SJustin Hibbits break; 32528cbb9b1SJustin Hibbits 32628cbb9b1SJustin Hibbits case EXC_DEBUG: /* Single stepping */ 32728cbb9b1SJustin Hibbits mtspr(SPR_DBSR, mfspr(SPR_DBSR)); 32828cbb9b1SJustin Hibbits frame->srr1 &= ~PSL_DE; 329fa133b6bSJustin Hibbits frame->cpu.booke.dbcr0 &= ~(DBCR0_IDM | DBCR0_IC); 33028cbb9b1SJustin Hibbits sig = SIGTRAP; 33128cbb9b1SJustin Hibbits ucode = TRAP_TRACE; 33228cbb9b1SJustin Hibbits break; 33328cbb9b1SJustin Hibbits 33428cbb9b1SJustin Hibbits case EXC_PGM: 33528cbb9b1SJustin Hibbits /* Identify the trap reason */ 336a72b9513SJustin Hibbits if (frame_is_trap_inst(frame)) { 33728cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS 33828cbb9b1SJustin Hibbits inst = fuword32((const void *)frame->srr0); 33928cbb9b1SJustin Hibbits if (inst == 0x0FFFDDDD && 34028cbb9b1SJustin Hibbits dtrace_pid_probe_ptr != NULL) { 3415bab6234SMark Johnston (*dtrace_pid_probe_ptr)(frame); 34228cbb9b1SJustin Hibbits break; 34328cbb9b1SJustin Hibbits } 34428cbb9b1SJustin Hibbits #endif 34528cbb9b1SJustin Hibbits sig = SIGTRAP; 34628cbb9b1SJustin Hibbits ucode = TRAP_BRKPT; 34728cbb9b1SJustin Hibbits } else { 34828cbb9b1SJustin Hibbits sig = ppc_instr_emulate(frame, td->td_pcb); 34928cbb9b1SJustin Hibbits if (sig == SIGILL) { 35028cbb9b1SJustin Hibbits if (frame->srr1 & EXC_PGM_PRIV) 35128cbb9b1SJustin Hibbits ucode = ILL_PRVOPC; 35228cbb9b1SJustin Hibbits else if (frame->srr1 & EXC_PGM_ILLEGAL) 35328cbb9b1SJustin Hibbits ucode = ILL_ILLOPC; 35428cbb9b1SJustin Hibbits } else if (sig == SIGFPE) 35528cbb9b1SJustin Hibbits ucode = FPE_FLTINV; /* Punt for now, invalid operation. */ 35628cbb9b1SJustin Hibbits } 35728cbb9b1SJustin Hibbits break; 35828cbb9b1SJustin Hibbits 35928cbb9b1SJustin Hibbits case EXC_MCHK: 36028cbb9b1SJustin Hibbits /* 36128cbb9b1SJustin Hibbits * Note that this may not be recoverable for the user 36228cbb9b1SJustin Hibbits * process, depending on the type of machine check, 36328cbb9b1SJustin Hibbits * but it at least prevents the kernel from dying. 36428cbb9b1SJustin Hibbits */ 36528cbb9b1SJustin Hibbits sig = SIGBUS; 36628cbb9b1SJustin Hibbits ucode = BUS_OBJERR; 36728cbb9b1SJustin Hibbits break; 36828cbb9b1SJustin Hibbits 36928cbb9b1SJustin Hibbits default: 37028cbb9b1SJustin Hibbits trap_fatal(frame); 37128cbb9b1SJustin Hibbits } 37228cbb9b1SJustin Hibbits } else { 37328cbb9b1SJustin Hibbits /* Kernel Mode Traps */ 37428cbb9b1SJustin Hibbits 37528cbb9b1SJustin Hibbits KASSERT(cold || td->td_ucred != NULL, 37628cbb9b1SJustin Hibbits ("kernel trap doesn't have ucred")); 37728cbb9b1SJustin Hibbits switch (type) { 37828cbb9b1SJustin Hibbits case EXC_PGM: 37915fc4ab7SJustin Hibbits #ifdef KDTRACE_HOOKS 380a72b9513SJustin Hibbits if (frame_is_trap_inst(frame)) { 38128cbb9b1SJustin Hibbits if (*(uint32_t *)frame->srr0 == EXC_DTRACE) { 38228cbb9b1SJustin Hibbits if (dtrace_invop_jump_addr != NULL) { 38328cbb9b1SJustin Hibbits dtrace_invop_jump_addr(frame); 38428cbb9b1SJustin Hibbits return; 38528cbb9b1SJustin Hibbits } 38628cbb9b1SJustin Hibbits } 38728cbb9b1SJustin Hibbits } 38828cbb9b1SJustin Hibbits #endif 38915fc4ab7SJustin Hibbits #ifdef KDB 39015fc4ab7SJustin Hibbits if (db_trap_glue(frame)) 39115fc4ab7SJustin Hibbits return; 39215fc4ab7SJustin Hibbits #endif 39315fc4ab7SJustin Hibbits break; 394d5a30121SJustin Hibbits #if defined(__powerpc64__) && defined(AIM) 39528cbb9b1SJustin Hibbits case EXC_DSE: 396eb1baf72SNathan Whitehorn if (td->td_pcb->pcb_cpu.aim.usr_vsid != 0 && 397eb1baf72SNathan Whitehorn (frame->dar & SEGMENT_MASK) == USER_ADDR) { 39828cbb9b1SJustin Hibbits __asm __volatile ("slbmte %0, %1" :: 39928cbb9b1SJustin Hibbits "r"(td->td_pcb->pcb_cpu.aim.usr_vsid), 40028cbb9b1SJustin Hibbits "r"(USER_SLB_SLBE)); 40128cbb9b1SJustin Hibbits return; 40228cbb9b1SJustin Hibbits } 40328cbb9b1SJustin Hibbits break; 40428cbb9b1SJustin Hibbits #endif 40528cbb9b1SJustin Hibbits case EXC_DSI: 40628cbb9b1SJustin Hibbits if (trap_pfault(frame, 0) == 0) 40728cbb9b1SJustin Hibbits return; 40828cbb9b1SJustin Hibbits break; 40928cbb9b1SJustin Hibbits case EXC_MCHK: 41028cbb9b1SJustin Hibbits if (handle_onfault(frame)) 41128cbb9b1SJustin Hibbits return; 41228cbb9b1SJustin Hibbits break; 41328cbb9b1SJustin Hibbits default: 41428cbb9b1SJustin Hibbits break; 41528cbb9b1SJustin Hibbits } 41628cbb9b1SJustin Hibbits trap_fatal(frame); 41728cbb9b1SJustin Hibbits } 41828cbb9b1SJustin Hibbits 41928cbb9b1SJustin Hibbits if (sig != 0) { 42028cbb9b1SJustin Hibbits if (p->p_sysent->sv_transtrap != NULL) 42128cbb9b1SJustin Hibbits sig = (p->p_sysent->sv_transtrap)(sig, type); 42228cbb9b1SJustin Hibbits ksiginfo_init_trap(&ksi); 42328cbb9b1SJustin Hibbits ksi.ksi_signo = sig; 42428cbb9b1SJustin Hibbits ksi.ksi_code = (int) ucode; /* XXX, not POSIX */ 42528cbb9b1SJustin Hibbits /* ksi.ksi_addr = ? */ 42628cbb9b1SJustin Hibbits ksi.ksi_trapno = type; 42728cbb9b1SJustin Hibbits trapsignal(td, &ksi); 42828cbb9b1SJustin Hibbits } 42928cbb9b1SJustin Hibbits 43028cbb9b1SJustin Hibbits userret(td, frame); 43128cbb9b1SJustin Hibbits } 43228cbb9b1SJustin Hibbits 43328cbb9b1SJustin Hibbits static void 43428cbb9b1SJustin Hibbits trap_fatal(struct trapframe *frame) 43528cbb9b1SJustin Hibbits { 43628cbb9b1SJustin Hibbits 43728cbb9b1SJustin Hibbits printtrap(frame->exc, frame, 1, (frame->srr1 & PSL_PR)); 43828cbb9b1SJustin Hibbits #ifdef KDB 43928cbb9b1SJustin Hibbits if ((debugger_on_panic || kdb_active) && 44028cbb9b1SJustin Hibbits kdb_trap(frame->exc, 0, frame)) 44128cbb9b1SJustin Hibbits return; 44228cbb9b1SJustin Hibbits #endif 44328cbb9b1SJustin Hibbits panic("%s trap", trapname(frame->exc)); 44428cbb9b1SJustin Hibbits } 44528cbb9b1SJustin Hibbits 44628cbb9b1SJustin Hibbits static void 44728cbb9b1SJustin Hibbits printtrap(u_int vector, struct trapframe *frame, int isfatal, int user) 44828cbb9b1SJustin Hibbits { 449398973f8SJustin Hibbits uint16_t ver; 4506035018bSJustin Hibbits #ifdef BOOKE 4516035018bSJustin Hibbits vm_paddr_t pa; 4526035018bSJustin Hibbits #endif 45328cbb9b1SJustin Hibbits 45428cbb9b1SJustin Hibbits printf("\n"); 45528cbb9b1SJustin Hibbits printf("%s %s trap:\n", isfatal ? "fatal" : "handled", 45628cbb9b1SJustin Hibbits user ? "user" : "kernel"); 45728cbb9b1SJustin Hibbits printf("\n"); 45828cbb9b1SJustin Hibbits printf(" exception = 0x%x (%s)\n", vector, trapname(vector)); 45928cbb9b1SJustin Hibbits switch (vector) { 46028cbb9b1SJustin Hibbits case EXC_DSE: 46128cbb9b1SJustin Hibbits case EXC_DSI: 46239a4b70fSJustin Hibbits case EXC_DTMISS: 46328cbb9b1SJustin Hibbits printf(" virtual address = 0x%" PRIxPTR "\n", frame->dar); 46439a4b70fSJustin Hibbits #ifdef AIM 465cf5aa326SJustin Hibbits printf(" dsisr = 0x%lx\n", 466cf5aa326SJustin Hibbits (u_long)frame->cpu.aim.dsisr); 46739a4b70fSJustin Hibbits #endif 46828cbb9b1SJustin Hibbits break; 46928cbb9b1SJustin Hibbits case EXC_ISE: 47028cbb9b1SJustin Hibbits case EXC_ISI: 47139a4b70fSJustin Hibbits case EXC_ITMISS: 47228cbb9b1SJustin Hibbits printf(" virtual address = 0x%" PRIxPTR "\n", frame->srr0); 47328cbb9b1SJustin Hibbits break; 474398973f8SJustin Hibbits case EXC_MCHK: 475398973f8SJustin Hibbits ver = mfpvr() >> 16; 476398973f8SJustin Hibbits #if defined(AIM) 477398973f8SJustin Hibbits if (MPC745X_P(ver)) 478bf1b9296SJustin Hibbits printf(" msssr0 = 0x%b\n", 479bf1b9296SJustin Hibbits (int)mfspr(SPR_MSSSR0), MSSSR_BITMASK); 480398973f8SJustin Hibbits #elif defined(BOOKE) 4816035018bSJustin Hibbits pa = mfspr(SPR_MCARU); 48201a40173SJustin Hibbits pa = (pa << 32) | (u_register_t)mfspr(SPR_MCAR); 483bf1b9296SJustin Hibbits printf(" mcsr = 0x%b\n", 484bf1b9296SJustin Hibbits (int)mfspr(SPR_MCSR), MCSR_BITMASK); 4856035018bSJustin Hibbits printf(" mcar = 0x%jx\n", (uintmax_t)pa); 486398973f8SJustin Hibbits #endif 487398973f8SJustin Hibbits break; 48828cbb9b1SJustin Hibbits } 48939a4b70fSJustin Hibbits #ifdef BOOKE 490bf1b9296SJustin Hibbits printf(" esr = 0x%b\n", 491bf1b9296SJustin Hibbits (int)frame->cpu.booke.esr, ESR_BITMASK); 49239a4b70fSJustin Hibbits #endif 493ec75f647SNathan Whitehorn printf(" srr0 = 0x%" PRIxPTR " (0x%" PRIxPTR ")\n", 4944e05ac24SNathan Whitehorn frame->srr0, frame->srr0 - (register_t)(__startkernel - KERNBASE)); 495cf5aa326SJustin Hibbits printf(" srr1 = 0x%lx\n", (u_long)frame->srr1); 496ec75f647SNathan Whitehorn printf(" lr = 0x%" PRIxPTR " (0x%" PRIxPTR ")\n", 4974e05ac24SNathan Whitehorn frame->lr, frame->lr - (register_t)(__startkernel - KERNBASE)); 49828cbb9b1SJustin Hibbits printf(" curthread = %p\n", curthread); 49928cbb9b1SJustin Hibbits if (curthread != NULL) 50028cbb9b1SJustin Hibbits printf(" pid = %d, comm = %s\n", 50128cbb9b1SJustin Hibbits curthread->td_proc->p_pid, curthread->td_name); 50228cbb9b1SJustin Hibbits printf("\n"); 50328cbb9b1SJustin Hibbits } 50428cbb9b1SJustin Hibbits 50528cbb9b1SJustin Hibbits /* 50628cbb9b1SJustin Hibbits * Handles a fatal fault when we have onfault state to recover. Returns 50728cbb9b1SJustin Hibbits * non-zero if there was onfault recovery state available. 50828cbb9b1SJustin Hibbits */ 50928cbb9b1SJustin Hibbits static int 51028cbb9b1SJustin Hibbits handle_onfault(struct trapframe *frame) 51128cbb9b1SJustin Hibbits { 51228cbb9b1SJustin Hibbits struct thread *td; 513a18c313eSNathan Whitehorn jmp_buf *fb; 51428cbb9b1SJustin Hibbits 51528cbb9b1SJustin Hibbits td = curthread; 51628cbb9b1SJustin Hibbits fb = td->td_pcb->pcb_onfault; 51728cbb9b1SJustin Hibbits if (fb != NULL) { 518a18c313eSNathan Whitehorn frame->srr0 = (*fb)->_jb[FAULTBUF_LR]; 519a18c313eSNathan Whitehorn frame->fixreg[1] = (*fb)->_jb[FAULTBUF_R1]; 520a18c313eSNathan Whitehorn frame->fixreg[2] = (*fb)->_jb[FAULTBUF_R2]; 52128cbb9b1SJustin Hibbits frame->fixreg[3] = 1; 522a18c313eSNathan Whitehorn frame->cr = (*fb)->_jb[FAULTBUF_CR]; 523a18c313eSNathan Whitehorn bcopy(&(*fb)->_jb[FAULTBUF_R14], &frame->fixreg[14], 524a18c313eSNathan Whitehorn 18 * sizeof(register_t)); 525a18c313eSNathan Whitehorn td->td_pcb->pcb_onfault = NULL; /* Returns twice, not thrice */ 52628cbb9b1SJustin Hibbits return (1); 52728cbb9b1SJustin Hibbits } 52828cbb9b1SJustin Hibbits return (0); 52928cbb9b1SJustin Hibbits } 53028cbb9b1SJustin Hibbits 53128cbb9b1SJustin Hibbits int 5322d88da2fSKonstantin Belousov cpu_fetch_syscall_args(struct thread *td) 53328cbb9b1SJustin Hibbits { 53428cbb9b1SJustin Hibbits struct proc *p; 53528cbb9b1SJustin Hibbits struct trapframe *frame; 5362d88da2fSKonstantin Belousov struct syscall_args *sa; 53728cbb9b1SJustin Hibbits caddr_t params; 53828cbb9b1SJustin Hibbits size_t argsz; 53928cbb9b1SJustin Hibbits int error, n, i; 54028cbb9b1SJustin Hibbits 54128cbb9b1SJustin Hibbits p = td->td_proc; 54228cbb9b1SJustin Hibbits frame = td->td_frame; 5432d88da2fSKonstantin Belousov sa = &td->td_sa; 54428cbb9b1SJustin Hibbits 54528cbb9b1SJustin Hibbits sa->code = frame->fixreg[0]; 54628cbb9b1SJustin Hibbits params = (caddr_t)(frame->fixreg + FIRSTARG); 54728cbb9b1SJustin Hibbits n = NARGREG; 54828cbb9b1SJustin Hibbits 54928cbb9b1SJustin Hibbits if (sa->code == SYS_syscall) { 55028cbb9b1SJustin Hibbits /* 55128cbb9b1SJustin Hibbits * code is first argument, 55228cbb9b1SJustin Hibbits * followed by actual args. 55328cbb9b1SJustin Hibbits */ 55428cbb9b1SJustin Hibbits sa->code = *(register_t *) params; 55528cbb9b1SJustin Hibbits params += sizeof(register_t); 55628cbb9b1SJustin Hibbits n -= 1; 55728cbb9b1SJustin Hibbits } else if (sa->code == SYS___syscall) { 55828cbb9b1SJustin Hibbits /* 55928cbb9b1SJustin Hibbits * Like syscall, but code is a quad, 56028cbb9b1SJustin Hibbits * so as to maintain quad alignment 56128cbb9b1SJustin Hibbits * for the rest of the args. 56228cbb9b1SJustin Hibbits */ 56328cbb9b1SJustin Hibbits if (SV_PROC_FLAG(p, SV_ILP32)) { 56428cbb9b1SJustin Hibbits params += sizeof(register_t); 56528cbb9b1SJustin Hibbits sa->code = *(register_t *) params; 56628cbb9b1SJustin Hibbits params += sizeof(register_t); 56728cbb9b1SJustin Hibbits n -= 2; 56828cbb9b1SJustin Hibbits } else { 56928cbb9b1SJustin Hibbits sa->code = *(register_t *) params; 57028cbb9b1SJustin Hibbits params += sizeof(register_t); 57128cbb9b1SJustin Hibbits n -= 1; 57228cbb9b1SJustin Hibbits } 57328cbb9b1SJustin Hibbits } 57428cbb9b1SJustin Hibbits 57528cbb9b1SJustin Hibbits if (p->p_sysent->sv_mask) 57628cbb9b1SJustin Hibbits sa->code &= p->p_sysent->sv_mask; 57728cbb9b1SJustin Hibbits if (sa->code >= p->p_sysent->sv_size) 57828cbb9b1SJustin Hibbits sa->callp = &p->p_sysent->sv_table[0]; 57928cbb9b1SJustin Hibbits else 58028cbb9b1SJustin Hibbits sa->callp = &p->p_sysent->sv_table[sa->code]; 58128cbb9b1SJustin Hibbits 58228cbb9b1SJustin Hibbits sa->narg = sa->callp->sy_narg; 58328cbb9b1SJustin Hibbits 58428cbb9b1SJustin Hibbits if (SV_PROC_FLAG(p, SV_ILP32)) { 58528cbb9b1SJustin Hibbits argsz = sizeof(uint32_t); 58628cbb9b1SJustin Hibbits 58728cbb9b1SJustin Hibbits for (i = 0; i < n; i++) 58828cbb9b1SJustin Hibbits sa->args[i] = ((u_register_t *)(params))[i] & 58928cbb9b1SJustin Hibbits 0xffffffff; 59028cbb9b1SJustin Hibbits } else { 59128cbb9b1SJustin Hibbits argsz = sizeof(uint64_t); 59228cbb9b1SJustin Hibbits 59328cbb9b1SJustin Hibbits for (i = 0; i < n; i++) 59428cbb9b1SJustin Hibbits sa->args[i] = ((u_register_t *)(params))[i]; 59528cbb9b1SJustin Hibbits } 59628cbb9b1SJustin Hibbits 59728cbb9b1SJustin Hibbits if (sa->narg > n) 59828cbb9b1SJustin Hibbits error = copyin(MOREARGS(frame->fixreg[1]), sa->args + n, 59928cbb9b1SJustin Hibbits (sa->narg - n) * argsz); 60028cbb9b1SJustin Hibbits else 60128cbb9b1SJustin Hibbits error = 0; 60228cbb9b1SJustin Hibbits 60328cbb9b1SJustin Hibbits #ifdef __powerpc64__ 60428cbb9b1SJustin Hibbits if (SV_PROC_FLAG(p, SV_ILP32) && sa->narg > n) { 60528cbb9b1SJustin Hibbits /* Expand the size of arguments copied from the stack */ 60628cbb9b1SJustin Hibbits 60728cbb9b1SJustin Hibbits for (i = sa->narg; i >= n; i--) 60828cbb9b1SJustin Hibbits sa->args[i] = ((uint32_t *)(&sa->args[n]))[i-n]; 60928cbb9b1SJustin Hibbits } 61028cbb9b1SJustin Hibbits #endif 61128cbb9b1SJustin Hibbits 61228cbb9b1SJustin Hibbits if (error == 0) { 61328cbb9b1SJustin Hibbits td->td_retval[0] = 0; 61428cbb9b1SJustin Hibbits td->td_retval[1] = frame->fixreg[FIRSTARG + 1]; 61528cbb9b1SJustin Hibbits } 61628cbb9b1SJustin Hibbits return (error); 61728cbb9b1SJustin Hibbits } 61828cbb9b1SJustin Hibbits 61928cbb9b1SJustin Hibbits #include "../../kern/subr_syscall.c" 62028cbb9b1SJustin Hibbits 62128cbb9b1SJustin Hibbits void 62228cbb9b1SJustin Hibbits syscall(struct trapframe *frame) 62328cbb9b1SJustin Hibbits { 62428cbb9b1SJustin Hibbits struct thread *td; 62528cbb9b1SJustin Hibbits int error; 62628cbb9b1SJustin Hibbits 62728cbb9b1SJustin Hibbits td = curthread; 62828cbb9b1SJustin Hibbits td->td_frame = frame; 62928cbb9b1SJustin Hibbits 630d5a30121SJustin Hibbits #if defined(__powerpc64__) && defined(AIM) 63128cbb9b1SJustin Hibbits /* 63228cbb9b1SJustin Hibbits * Speculatively restore last user SLB segment, which we know is 63328cbb9b1SJustin Hibbits * invalid already, since we are likely to do copyin()/copyout(). 63428cbb9b1SJustin Hibbits */ 635e649493cSNathan Whitehorn if (td->td_pcb->pcb_cpu.aim.usr_vsid != 0) 63628cbb9b1SJustin Hibbits __asm __volatile ("slbmte %0, %1; isync" :: 63728cbb9b1SJustin Hibbits "r"(td->td_pcb->pcb_cpu.aim.usr_vsid), "r"(USER_SLB_SLBE)); 63828cbb9b1SJustin Hibbits #endif 63928cbb9b1SJustin Hibbits 6402d88da2fSKonstantin Belousov error = syscallenter(td); 6412d88da2fSKonstantin Belousov syscallret(td, error); 64228cbb9b1SJustin Hibbits } 64328cbb9b1SJustin Hibbits 644d5a30121SJustin Hibbits #if defined(__powerpc64__) && defined(AIM) 64528cbb9b1SJustin Hibbits /* Handle kernel SLB faults -- runs in real mode, all seat belts off */ 64628cbb9b1SJustin Hibbits void 64728cbb9b1SJustin Hibbits handle_kernel_slb_spill(int type, register_t dar, register_t srr0) 64828cbb9b1SJustin Hibbits { 64928cbb9b1SJustin Hibbits struct slb *slbcache; 65028cbb9b1SJustin Hibbits uint64_t slbe, slbv; 65128cbb9b1SJustin Hibbits uint64_t esid, addr; 65228cbb9b1SJustin Hibbits int i; 65328cbb9b1SJustin Hibbits 65428cbb9b1SJustin Hibbits addr = (type == EXC_ISE) ? srr0 : dar; 655bce6d88bSJustin Hibbits slbcache = PCPU_GET(aim.slb); 65628cbb9b1SJustin Hibbits esid = (uintptr_t)addr >> ADDR_SR_SHFT; 65728cbb9b1SJustin Hibbits slbe = (esid << SLBE_ESID_SHIFT) | SLBE_VALID; 65828cbb9b1SJustin Hibbits 65928cbb9b1SJustin Hibbits /* See if the hardware flushed this somehow (can happen in LPARs) */ 66028cbb9b1SJustin Hibbits for (i = 0; i < n_slbs; i++) 66128cbb9b1SJustin Hibbits if (slbcache[i].slbe == (slbe | (uint64_t)i)) 66228cbb9b1SJustin Hibbits return; 66328cbb9b1SJustin Hibbits 66428cbb9b1SJustin Hibbits /* Not in the map, needs to actually be added */ 66528cbb9b1SJustin Hibbits slbv = kernel_va_to_slbv(addr); 66628cbb9b1SJustin Hibbits if (slbcache[USER_SLB_SLOT].slbe == 0) { 66728cbb9b1SJustin Hibbits for (i = 0; i < n_slbs; i++) { 66828cbb9b1SJustin Hibbits if (i == USER_SLB_SLOT) 66928cbb9b1SJustin Hibbits continue; 67028cbb9b1SJustin Hibbits if (!(slbcache[i].slbe & SLBE_VALID)) 67128cbb9b1SJustin Hibbits goto fillkernslb; 67228cbb9b1SJustin Hibbits } 67328cbb9b1SJustin Hibbits 67428cbb9b1SJustin Hibbits if (i == n_slbs) 67528cbb9b1SJustin Hibbits slbcache[USER_SLB_SLOT].slbe = 1; 67628cbb9b1SJustin Hibbits } 67728cbb9b1SJustin Hibbits 67828cbb9b1SJustin Hibbits /* Sacrifice a random SLB entry that is not the user entry */ 67928cbb9b1SJustin Hibbits i = mftb() % n_slbs; 68028cbb9b1SJustin Hibbits if (i == USER_SLB_SLOT) 68128cbb9b1SJustin Hibbits i = (i+1) % n_slbs; 68228cbb9b1SJustin Hibbits 68328cbb9b1SJustin Hibbits fillkernslb: 68428cbb9b1SJustin Hibbits /* Write new entry */ 68528cbb9b1SJustin Hibbits slbcache[i].slbv = slbv; 68628cbb9b1SJustin Hibbits slbcache[i].slbe = slbe | (uint64_t)i; 68728cbb9b1SJustin Hibbits 68828cbb9b1SJustin Hibbits /* Trap handler will restore from cache on exit */ 68928cbb9b1SJustin Hibbits } 69028cbb9b1SJustin Hibbits 69128cbb9b1SJustin Hibbits static int 69228cbb9b1SJustin Hibbits handle_user_slb_spill(pmap_t pm, vm_offset_t addr) 69328cbb9b1SJustin Hibbits { 69428cbb9b1SJustin Hibbits struct slb *user_entry; 69528cbb9b1SJustin Hibbits uint64_t esid; 69628cbb9b1SJustin Hibbits int i; 69728cbb9b1SJustin Hibbits 698e649493cSNathan Whitehorn if (pm->pm_slb == NULL) 699e649493cSNathan Whitehorn return (-1); 700e649493cSNathan Whitehorn 70128cbb9b1SJustin Hibbits esid = (uintptr_t)addr >> ADDR_SR_SHFT; 70228cbb9b1SJustin Hibbits 70328cbb9b1SJustin Hibbits PMAP_LOCK(pm); 70428cbb9b1SJustin Hibbits user_entry = user_va_to_slb_entry(pm, addr); 70528cbb9b1SJustin Hibbits 70628cbb9b1SJustin Hibbits if (user_entry == NULL) { 70728cbb9b1SJustin Hibbits /* allocate_vsid auto-spills it */ 70828cbb9b1SJustin Hibbits (void)allocate_user_vsid(pm, esid, 0); 70928cbb9b1SJustin Hibbits } else { 71028cbb9b1SJustin Hibbits /* 71128cbb9b1SJustin Hibbits * Check that another CPU has not already mapped this. 71228cbb9b1SJustin Hibbits * XXX: Per-thread SLB caches would be better. 71328cbb9b1SJustin Hibbits */ 71428cbb9b1SJustin Hibbits for (i = 0; i < pm->pm_slb_len; i++) 71528cbb9b1SJustin Hibbits if (pm->pm_slb[i] == user_entry) 71628cbb9b1SJustin Hibbits break; 71728cbb9b1SJustin Hibbits 71828cbb9b1SJustin Hibbits if (i == pm->pm_slb_len) 71928cbb9b1SJustin Hibbits slb_insert_user(pm, user_entry); 72028cbb9b1SJustin Hibbits } 72128cbb9b1SJustin Hibbits PMAP_UNLOCK(pm); 72228cbb9b1SJustin Hibbits 72328cbb9b1SJustin Hibbits return (0); 72428cbb9b1SJustin Hibbits } 72528cbb9b1SJustin Hibbits #endif 72628cbb9b1SJustin Hibbits 72728cbb9b1SJustin Hibbits static int 72828cbb9b1SJustin Hibbits trap_pfault(struct trapframe *frame, int user) 72928cbb9b1SJustin Hibbits { 73028cbb9b1SJustin Hibbits vm_offset_t eva, va; 73128cbb9b1SJustin Hibbits struct thread *td; 73228cbb9b1SJustin Hibbits struct proc *p; 73328cbb9b1SJustin Hibbits vm_map_t map; 73428cbb9b1SJustin Hibbits vm_prot_t ftype; 735eb1baf72SNathan Whitehorn int rv, is_user; 73628cbb9b1SJustin Hibbits 73728cbb9b1SJustin Hibbits td = curthread; 73828cbb9b1SJustin Hibbits p = td->td_proc; 73928cbb9b1SJustin Hibbits if (frame->exc == EXC_ISI) { 74028cbb9b1SJustin Hibbits eva = frame->srr0; 74128cbb9b1SJustin Hibbits ftype = VM_PROT_EXECUTE; 74228cbb9b1SJustin Hibbits if (frame->srr1 & SRR1_ISI_PFAULT) 74328cbb9b1SJustin Hibbits ftype |= VM_PROT_READ; 74428cbb9b1SJustin Hibbits } else { 74528cbb9b1SJustin Hibbits eva = frame->dar; 74628cbb9b1SJustin Hibbits #ifdef BOOKE 74728cbb9b1SJustin Hibbits if (frame->cpu.booke.esr & ESR_ST) 74828cbb9b1SJustin Hibbits #else 74928cbb9b1SJustin Hibbits if (frame->cpu.aim.dsisr & DSISR_STORE) 75028cbb9b1SJustin Hibbits #endif 75128cbb9b1SJustin Hibbits ftype = VM_PROT_WRITE; 75228cbb9b1SJustin Hibbits else 75328cbb9b1SJustin Hibbits ftype = VM_PROT_READ; 75428cbb9b1SJustin Hibbits } 75528cbb9b1SJustin Hibbits 75628cbb9b1SJustin Hibbits if (user) { 75728cbb9b1SJustin Hibbits KASSERT(p->p_vmspace != NULL, ("trap_pfault: vmspace NULL")); 75828cbb9b1SJustin Hibbits map = &p->p_vmspace->vm_map; 75928cbb9b1SJustin Hibbits } else { 760eb1baf72SNathan Whitehorn rv = pmap_decode_kernel_ptr(eva, &is_user, &eva); 761eb1baf72SNathan Whitehorn if (rv != 0) 762eb1baf72SNathan Whitehorn return (SIGSEGV); 76328cbb9b1SJustin Hibbits 764eb1baf72SNathan Whitehorn if (is_user) 765eb1baf72SNathan Whitehorn map = &p->p_vmspace->vm_map; 766eb1baf72SNathan Whitehorn else 76728cbb9b1SJustin Hibbits map = kernel_map; 76828cbb9b1SJustin Hibbits } 76928cbb9b1SJustin Hibbits va = trunc_page(eva); 77028cbb9b1SJustin Hibbits 7711fa67124SKonstantin Belousov /* Fault in the page. */ 77228cbb9b1SJustin Hibbits rv = vm_fault(map, va, ftype, VM_FAULT_NORMAL); 77328cbb9b1SJustin Hibbits /* 77428cbb9b1SJustin Hibbits * XXXDTRACE: add dtrace_doubletrap_func here? 77528cbb9b1SJustin Hibbits */ 77628cbb9b1SJustin Hibbits 77728cbb9b1SJustin Hibbits if (rv == KERN_SUCCESS) 77828cbb9b1SJustin Hibbits return (0); 77928cbb9b1SJustin Hibbits 78028cbb9b1SJustin Hibbits if (!user && handle_onfault(frame)) 78128cbb9b1SJustin Hibbits return (0); 78228cbb9b1SJustin Hibbits 78328cbb9b1SJustin Hibbits return (SIGSEGV); 78428cbb9b1SJustin Hibbits } 78528cbb9b1SJustin Hibbits 78628cbb9b1SJustin Hibbits /* 78728cbb9b1SJustin Hibbits * For now, this only deals with the particular unaligned access case 78828cbb9b1SJustin Hibbits * that gcc tends to generate. Eventually it should handle all of the 78928cbb9b1SJustin Hibbits * possibilities that can happen on a 32-bit PowerPC in big-endian mode. 79028cbb9b1SJustin Hibbits */ 79128cbb9b1SJustin Hibbits 79228cbb9b1SJustin Hibbits static int 79328cbb9b1SJustin Hibbits fix_unaligned(struct thread *td, struct trapframe *frame) 79428cbb9b1SJustin Hibbits { 79528cbb9b1SJustin Hibbits struct thread *fputhread; 796dc9b124dSJustin Hibbits #ifdef __SPE__ 797dc9b124dSJustin Hibbits uint32_t inst; 798dc9b124dSJustin Hibbits #endif 79928cbb9b1SJustin Hibbits int indicator, reg; 80028cbb9b1SJustin Hibbits double *fpr; 80128cbb9b1SJustin Hibbits 802dc9b124dSJustin Hibbits #ifdef __SPE__ 803dc9b124dSJustin Hibbits indicator = (frame->cpu.booke.esr & (ESR_ST|ESR_SPE)); 804dc9b124dSJustin Hibbits if (indicator & ESR_SPE) { 805dc9b124dSJustin Hibbits if (copyin((void *)frame->srr0, &inst, sizeof(inst)) != 0) 806dc9b124dSJustin Hibbits return (-1); 807dc9b124dSJustin Hibbits reg = EXC_ALI_SPE_REG(inst); 808dc9b124dSJustin Hibbits fpr = (double *)td->td_pcb->pcb_vec.vr[reg]; 809dc9b124dSJustin Hibbits fputhread = PCPU_GET(vecthread); 810dc9b124dSJustin Hibbits 81189965e70SJustin Hibbits /* Juggle the SPE to ensure that we've initialized 81289965e70SJustin Hibbits * the registers, and that their current state is in 813dc9b124dSJustin Hibbits * the PCB. 814dc9b124dSJustin Hibbits */ 815eaa5e396SJustin Hibbits if (fputhread != td) { 816eaa5e396SJustin Hibbits if (fputhread) 817eaa5e396SJustin Hibbits save_vec(fputhread); 818dc9b124dSJustin Hibbits enable_vec(td); 819dc9b124dSJustin Hibbits } 820dc9b124dSJustin Hibbits save_vec(td); 821dc9b124dSJustin Hibbits 822dc9b124dSJustin Hibbits if (!(indicator & ESR_ST)) { 823dc9b124dSJustin Hibbits if (copyin((void *)frame->dar, fpr, 824dc9b124dSJustin Hibbits sizeof(double)) != 0) 825dc9b124dSJustin Hibbits return (-1); 826dc9b124dSJustin Hibbits frame->fixreg[reg] = td->td_pcb->pcb_vec.vr[reg][1]; 827dc9b124dSJustin Hibbits enable_vec(td); 828dc9b124dSJustin Hibbits } else { 829dc9b124dSJustin Hibbits td->td_pcb->pcb_vec.vr[reg][1] = frame->fixreg[reg]; 830dc9b124dSJustin Hibbits if (copyout(fpr, (void *)frame->dar, 831dc9b124dSJustin Hibbits sizeof(double)) != 0) 832dc9b124dSJustin Hibbits return (-1); 833dc9b124dSJustin Hibbits } 834dc9b124dSJustin Hibbits return (0); 835dc9b124dSJustin Hibbits } 836dc9b124dSJustin Hibbits #else 83728cbb9b1SJustin Hibbits indicator = EXC_ALI_OPCODE_INDICATOR(frame->cpu.aim.dsisr); 83828cbb9b1SJustin Hibbits 83928cbb9b1SJustin Hibbits switch (indicator) { 84028cbb9b1SJustin Hibbits case EXC_ALI_LFD: 84128cbb9b1SJustin Hibbits case EXC_ALI_STFD: 84228cbb9b1SJustin Hibbits reg = EXC_ALI_RST(frame->cpu.aim.dsisr); 84328cbb9b1SJustin Hibbits fpr = &td->td_pcb->pcb_fpu.fpr[reg].fpr; 84428cbb9b1SJustin Hibbits fputhread = PCPU_GET(fputhread); 84528cbb9b1SJustin Hibbits 84628cbb9b1SJustin Hibbits /* Juggle the FPU to ensure that we've initialized 84728cbb9b1SJustin Hibbits * the FPRs, and that their current state is in 84828cbb9b1SJustin Hibbits * the PCB. 84928cbb9b1SJustin Hibbits */ 85028cbb9b1SJustin Hibbits if (fputhread != td) { 85128cbb9b1SJustin Hibbits if (fputhread) 85228cbb9b1SJustin Hibbits save_fpu(fputhread); 85328cbb9b1SJustin Hibbits enable_fpu(td); 85428cbb9b1SJustin Hibbits } 85528cbb9b1SJustin Hibbits save_fpu(td); 85628cbb9b1SJustin Hibbits 85728cbb9b1SJustin Hibbits if (indicator == EXC_ALI_LFD) { 85828cbb9b1SJustin Hibbits if (copyin((void *)frame->dar, fpr, 85928cbb9b1SJustin Hibbits sizeof(double)) != 0) 86028cbb9b1SJustin Hibbits return (-1); 86128cbb9b1SJustin Hibbits enable_fpu(td); 86228cbb9b1SJustin Hibbits } else { 86328cbb9b1SJustin Hibbits if (copyout(fpr, (void *)frame->dar, 86428cbb9b1SJustin Hibbits sizeof(double)) != 0) 86528cbb9b1SJustin Hibbits return (-1); 86628cbb9b1SJustin Hibbits } 86728cbb9b1SJustin Hibbits return (0); 86828cbb9b1SJustin Hibbits break; 86928cbb9b1SJustin Hibbits } 870dc9b124dSJustin Hibbits #endif 87128cbb9b1SJustin Hibbits 87228cbb9b1SJustin Hibbits return (-1); 87328cbb9b1SJustin Hibbits } 87428cbb9b1SJustin Hibbits 87528cbb9b1SJustin Hibbits #ifdef KDB 87628cbb9b1SJustin Hibbits int 87728cbb9b1SJustin Hibbits db_trap_glue(struct trapframe *frame) 87828cbb9b1SJustin Hibbits { 87915fc4ab7SJustin Hibbits 88028cbb9b1SJustin Hibbits if (!(frame->srr1 & PSL_PR) 88128cbb9b1SJustin Hibbits && (frame->exc == EXC_TRC || frame->exc == EXC_RUNMODETRC 882a72b9513SJustin Hibbits || frame_is_trap_inst(frame) 88328cbb9b1SJustin Hibbits || frame->exc == EXC_BPT 88428cbb9b1SJustin Hibbits || frame->exc == EXC_DSI)) { 88528cbb9b1SJustin Hibbits int type = frame->exc; 88628cbb9b1SJustin Hibbits 88728cbb9b1SJustin Hibbits /* Ignore DTrace traps. */ 88828cbb9b1SJustin Hibbits if (*(uint32_t *)frame->srr0 == EXC_DTRACE) 88928cbb9b1SJustin Hibbits return (0); 890a72b9513SJustin Hibbits if (frame_is_trap_inst(frame)) { 89128cbb9b1SJustin Hibbits type = T_BREAKPOINT; 89228cbb9b1SJustin Hibbits } 89328cbb9b1SJustin Hibbits return (kdb_trap(type, 0, frame)); 89428cbb9b1SJustin Hibbits } 89528cbb9b1SJustin Hibbits 89628cbb9b1SJustin Hibbits return (0); 89728cbb9b1SJustin Hibbits } 89828cbb9b1SJustin Hibbits #endif 899