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/param.h>
3528cbb9b1SJustin Hibbits #include <sys/kdb.h>
3628cbb9b1SJustin Hibbits #include <sys/proc.h>
3728cbb9b1SJustin Hibbits #include <sys/ktr.h>
3828cbb9b1SJustin Hibbits #include <sys/lock.h>
3928cbb9b1SJustin Hibbits #include <sys/mutex.h>
4028cbb9b1SJustin Hibbits #include <sys/ptrace.h>
4128cbb9b1SJustin Hibbits #include <sys/reboot.h>
4228cbb9b1SJustin Hibbits #include <sys/syscall.h>
4328cbb9b1SJustin Hibbits #include <sys/sysent.h>
4428cbb9b1SJustin Hibbits #include <sys/systm.h>
4528cbb9b1SJustin Hibbits #include <sys/kernel.h>
4628cbb9b1SJustin Hibbits #include <sys/uio.h>
4728cbb9b1SJustin Hibbits #include <sys/signalvar.h>
4828cbb9b1SJustin Hibbits #include <sys/vmmeter.h>
4928cbb9b1SJustin Hibbits
5028cbb9b1SJustin Hibbits #include <security/audit/audit.h>
5128cbb9b1SJustin Hibbits
5228cbb9b1SJustin Hibbits #include <vm/vm.h>
5328cbb9b1SJustin Hibbits #include <vm/pmap.h>
5428cbb9b1SJustin Hibbits #include <vm/vm_extern.h>
5528cbb9b1SJustin Hibbits #include <vm/vm_param.h>
5628cbb9b1SJustin Hibbits #include <vm/vm_kern.h>
5728cbb9b1SJustin Hibbits #include <vm/vm_map.h>
5828cbb9b1SJustin Hibbits #include <vm/vm_page.h>
5928cbb9b1SJustin Hibbits
6028cbb9b1SJustin Hibbits #include <machine/_inttypes.h>
6128cbb9b1SJustin Hibbits #include <machine/altivec.h>
6228cbb9b1SJustin Hibbits #include <machine/cpu.h>
6328cbb9b1SJustin Hibbits #include <machine/db_machdep.h>
6428cbb9b1SJustin Hibbits #include <machine/fpu.h>
6528cbb9b1SJustin Hibbits #include <machine/frame.h>
6628cbb9b1SJustin Hibbits #include <machine/pcb.h>
6728cbb9b1SJustin Hibbits #include <machine/psl.h>
68988d63afSJustin Hibbits #include <machine/slb.h>
6928cbb9b1SJustin Hibbits #include <machine/spr.h>
7028cbb9b1SJustin Hibbits #include <machine/sr.h>
71988d63afSJustin Hibbits #include <machine/trap.h>
7228cbb9b1SJustin Hibbits
73a18c313eSNathan Whitehorn /* Below matches setjmp.S */
74a18c313eSNathan Whitehorn #define FAULTBUF_LR 21
7528cbb9b1SJustin Hibbits #define FAULTBUF_R1 1
7628cbb9b1SJustin Hibbits #define FAULTBUF_R2 2
77a18c313eSNathan Whitehorn #define FAULTBUF_CR 22
78a18c313eSNathan Whitehorn #define FAULTBUF_R14 3
7928cbb9b1SJustin Hibbits
803e7e31bdSJustin Hibbits #define MOREARGS(sp) ((caddr_t)((uintptr_t)(sp) + \
813e7e31bdSJustin Hibbits sizeof(struct callframe) - 3*sizeof(register_t))) /* more args go here */
823e7e31bdSJustin Hibbits
8328cbb9b1SJustin Hibbits static void trap_fatal(struct trapframe *frame);
8428cbb9b1SJustin Hibbits static void printtrap(u_int vector, struct trapframe *frame, int isfatal,
8528cbb9b1SJustin Hibbits int user);
86df08823dSKonstantin Belousov static bool trap_pfault(struct trapframe *frame, bool user, int *signo,
87df08823dSKonstantin Belousov int *ucode);
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
92d5a30121SJustin Hibbits #if defined(__powerpc64__) && defined(AIM)
93be2bd024SLeandro Lupori static void normalize_inputs(void);
9428cbb9b1SJustin Hibbits #endif
9528cbb9b1SJustin Hibbits
96ec75f647SNathan Whitehorn extern vm_offset_t __startkernel;
97ec75f647SNathan Whitehorn
98d3111144SJustin Hibbits extern int copy_fault(void);
99d3111144SJustin Hibbits extern int fusufault(void);
100d3111144SJustin Hibbits
10115fc4ab7SJustin Hibbits #ifdef KDB
10215fc4ab7SJustin Hibbits int db_trap_glue(struct trapframe *); /* Called from trap_subr.S */
10315fc4ab7SJustin Hibbits #endif
10415fc4ab7SJustin Hibbits
10528cbb9b1SJustin Hibbits struct powerpc_exception {
10628cbb9b1SJustin Hibbits u_int vector;
10728cbb9b1SJustin Hibbits char *name;
10828cbb9b1SJustin Hibbits };
10928cbb9b1SJustin Hibbits
11028cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS
11128cbb9b1SJustin Hibbits #include <sys/dtrace_bsd.h>
11228cbb9b1SJustin Hibbits
11328cbb9b1SJustin Hibbits int (*dtrace_invop_jump_addr)(struct trapframe *);
11428cbb9b1SJustin Hibbits #endif
11528cbb9b1SJustin Hibbits
11628cbb9b1SJustin Hibbits static struct powerpc_exception powerpc_exceptions[] = {
11728cbb9b1SJustin Hibbits { EXC_CRIT, "critical input" },
11828cbb9b1SJustin Hibbits { EXC_RST, "system reset" },
11928cbb9b1SJustin Hibbits { EXC_MCHK, "machine check" },
12028cbb9b1SJustin Hibbits { EXC_DSI, "data storage interrupt" },
12128cbb9b1SJustin Hibbits { EXC_DSE, "data segment exception" },
12228cbb9b1SJustin Hibbits { EXC_ISI, "instruction storage interrupt" },
12328cbb9b1SJustin Hibbits { EXC_ISE, "instruction segment exception" },
12428cbb9b1SJustin Hibbits { EXC_EXI, "external interrupt" },
12528cbb9b1SJustin Hibbits { EXC_ALI, "alignment" },
12628cbb9b1SJustin Hibbits { EXC_PGM, "program" },
127ec75f647SNathan Whitehorn { EXC_HEA, "hypervisor emulation assistance" },
12828cbb9b1SJustin Hibbits { EXC_FPU, "floating-point unavailable" },
12928cbb9b1SJustin Hibbits { EXC_APU, "auxiliary proc unavailable" },
13028cbb9b1SJustin Hibbits { EXC_DECR, "decrementer" },
13128cbb9b1SJustin Hibbits { EXC_FIT, "fixed-interval timer" },
13228cbb9b1SJustin Hibbits { EXC_WDOG, "watchdog timer" },
13328cbb9b1SJustin Hibbits { EXC_SC, "system call" },
13428cbb9b1SJustin Hibbits { EXC_TRC, "trace" },
13528cbb9b1SJustin Hibbits { EXC_FPA, "floating-point assist" },
13628cbb9b1SJustin Hibbits { EXC_DEBUG, "debug" },
13728cbb9b1SJustin Hibbits { EXC_PERF, "performance monitoring" },
13828cbb9b1SJustin Hibbits { EXC_VEC, "altivec unavailable" },
13928cbb9b1SJustin Hibbits { EXC_VSX, "vsx unavailable" },
1407cd4e55cSJustin Hibbits { EXC_FAC, "facility unavailable" },
14128cbb9b1SJustin Hibbits { EXC_ITMISS, "instruction tlb miss" },
14228cbb9b1SJustin Hibbits { EXC_DLMISS, "data load tlb miss" },
14328cbb9b1SJustin Hibbits { EXC_DSMISS, "data store tlb miss" },
14428cbb9b1SJustin Hibbits { EXC_BPT, "instruction breakpoint" },
14528cbb9b1SJustin Hibbits { EXC_SMI, "system management" },
14628cbb9b1SJustin Hibbits { EXC_VECAST_G4, "altivec assist" },
14728cbb9b1SJustin Hibbits { EXC_THRM, "thermal management" },
14828cbb9b1SJustin Hibbits { EXC_RUNMODETRC, "run mode/trace" },
149be2bd024SLeandro Lupori { EXC_SOFT_PATCH, "soft patch exception" },
15028cbb9b1SJustin Hibbits { EXC_LAST, NULL }
15128cbb9b1SJustin Hibbits };
15228cbb9b1SJustin Hibbits
1539470013fSAlfredo Dal'Ava Junior static int uprintf_signal;
1549470013fSAlfredo Dal'Ava Junior SYSCTL_INT(_machdep, OID_AUTO, uprintf_signal, CTLFLAG_RWTUN,
1559470013fSAlfredo Dal'Ava Junior &uprintf_signal, 0,
1569470013fSAlfredo Dal'Ava Junior "Print debugging information on trap signal to ctty");
1579470013fSAlfredo Dal'Ava Junior
158bf1b9296SJustin Hibbits #define ESR_BITMASK \
159bf1b9296SJustin Hibbits "\20" \
160bf1b9296SJustin Hibbits "\040b0\037b1\036b2\035b3\034PIL\033PRR\032PTR\031FP" \
161bf1b9296SJustin Hibbits "\030ST\027b9\026DLK\025ILK\024b12\023b13\022BO\021PIE" \
162bf1b9296SJustin Hibbits "\020b16\017b17\016b18\015b19\014b20\013b21\012b22\011b23" \
163bf1b9296SJustin Hibbits "\010SPE\007EPID\006b26\005b27\004b28\003b29\002b30\001b31"
164bf1b9296SJustin Hibbits #define MCSR_BITMASK \
165bf1b9296SJustin Hibbits "\20" \
166bf1b9296SJustin Hibbits "\040MCP\037ICERR\036DCERR\035TLBPERR\034L2MMU_MHIT\033b5\032b6\031b7" \
167bf1b9296SJustin Hibbits "\030b8\027b9\026b10\025NMI\024MAV\023MEA\022b14\021IF" \
168bf1b9296SJustin Hibbits "\020LD\017ST\016LDG\015b19\014b20\013b21\012b22\011b23" \
169bf1b9296SJustin Hibbits "\010b24\007b25\006b26\005b27\004b28\003b29\002TLBSYNC\001BSL2_ERR"
170bf1b9296SJustin Hibbits #define MSSSR_BITMASK \
171bf1b9296SJustin Hibbits "\20" \
172bf1b9296SJustin Hibbits "\040b0\037b1\036b2\035b3\034b4\033b5\032b6\031b7" \
173bf1b9296SJustin Hibbits "\030b8\027b9\026b10\025b11\024b12\023L2TAG\022L2DAT\021L3TAG" \
174bf1b9296SJustin Hibbits "\020L3DAT\017APE\016DPE\015TEA\014b20\013b21\012b22\011b23" \
175bf1b9296SJustin Hibbits "\010b24\007b25\006b26\005b27\004b28\003b29\002b30\001b31"
176bf1b9296SJustin Hibbits
17728cbb9b1SJustin Hibbits static const char *
trapname(u_int vector)17828cbb9b1SJustin Hibbits trapname(u_int vector)
17928cbb9b1SJustin Hibbits {
18028cbb9b1SJustin Hibbits struct powerpc_exception *pe;
18128cbb9b1SJustin Hibbits
18228cbb9b1SJustin Hibbits for (pe = powerpc_exceptions; pe->vector != EXC_LAST; pe++) {
18328cbb9b1SJustin Hibbits if (pe->vector == vector)
18428cbb9b1SJustin Hibbits return (pe->name);
18528cbb9b1SJustin Hibbits }
18628cbb9b1SJustin Hibbits
18728cbb9b1SJustin Hibbits return ("unknown");
18828cbb9b1SJustin Hibbits }
18928cbb9b1SJustin Hibbits
190a72b9513SJustin Hibbits static inline bool
frame_is_trap_inst(struct trapframe * frame)191a72b9513SJustin Hibbits frame_is_trap_inst(struct trapframe *frame)
192a72b9513SJustin Hibbits {
193a72b9513SJustin Hibbits #ifdef AIM
194a72b9513SJustin Hibbits return (frame->exc == EXC_PGM && frame->srr1 & EXC_PGM_TRAP);
195a72b9513SJustin Hibbits #else
1969ae2eed9SJustin Hibbits return ((frame->cpu.booke.esr & ESR_PTR) != 0);
197a72b9513SJustin Hibbits #endif
198a72b9513SJustin Hibbits }
199a72b9513SJustin Hibbits
20028cbb9b1SJustin Hibbits void
trap(struct trapframe * frame)20128cbb9b1SJustin Hibbits trap(struct trapframe *frame)
20228cbb9b1SJustin Hibbits {
20328cbb9b1SJustin Hibbits struct thread *td;
20428cbb9b1SJustin Hibbits struct proc *p;
20528cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS
20628cbb9b1SJustin Hibbits uint32_t inst;
20728cbb9b1SJustin Hibbits #endif
20828cbb9b1SJustin Hibbits int sig, type, user;
20928cbb9b1SJustin Hibbits u_int ucode;
21028cbb9b1SJustin Hibbits ksiginfo_t ksi;
2117d351d60SJohn Baldwin register_t addr, fscr;
21228cbb9b1SJustin Hibbits
21383c9dea1SGleb Smirnoff VM_CNT_INC(v_trap);
21428cbb9b1SJustin Hibbits
215bda8aa77SJustin Hibbits #ifdef KDB
216bda8aa77SJustin Hibbits if (kdb_active) {
217bda8aa77SJustin Hibbits kdb_reenter();
218bda8aa77SJustin Hibbits return;
219bda8aa77SJustin Hibbits }
220bda8aa77SJustin Hibbits #endif
221bda8aa77SJustin Hibbits
22228cbb9b1SJustin Hibbits td = curthread;
22328cbb9b1SJustin Hibbits p = td->td_proc;
22428cbb9b1SJustin Hibbits
22528cbb9b1SJustin Hibbits type = ucode = frame->exc;
22628cbb9b1SJustin Hibbits sig = 0;
22728cbb9b1SJustin Hibbits user = frame->srr1 & PSL_PR;
2287d351d60SJohn Baldwin addr = 0;
22928cbb9b1SJustin Hibbits
23028cbb9b1SJustin Hibbits CTR3(KTR_TRAP, "trap: %s type=%s (%s)", td->td_name,
23128cbb9b1SJustin Hibbits trapname(type), user ? "user" : "kernel");
23228cbb9b1SJustin Hibbits
23328cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS
23428cbb9b1SJustin Hibbits /*
23528cbb9b1SJustin Hibbits * A trap can occur while DTrace executes a probe. Before
23628cbb9b1SJustin Hibbits * executing the probe, DTrace blocks re-scheduling and sets
23728cbb9b1SJustin Hibbits * a flag in its per-cpu flags to indicate that it doesn't
23828cbb9b1SJustin Hibbits * want to fault. On returning from the probe, the no-fault
23928cbb9b1SJustin Hibbits * flag is cleared and finally re-scheduling is enabled.
24028cbb9b1SJustin Hibbits *
24128cbb9b1SJustin Hibbits * If the DTrace kernel module has registered a trap handler,
24228cbb9b1SJustin Hibbits * call it and if it returns non-zero, assume that it has
24328cbb9b1SJustin Hibbits * handled the trap and modified the trap frame so that this
24428cbb9b1SJustin Hibbits * function can return normally.
24528cbb9b1SJustin Hibbits */
24628cbb9b1SJustin Hibbits if (dtrace_trap_func != NULL && (*dtrace_trap_func)(frame, type) != 0)
24728cbb9b1SJustin Hibbits return;
24828cbb9b1SJustin Hibbits #endif
24928cbb9b1SJustin Hibbits
25028cbb9b1SJustin Hibbits if (user) {
25128cbb9b1SJustin Hibbits td->td_pticks = 0;
25228cbb9b1SJustin Hibbits td->td_frame = frame;
2537d351d60SJohn Baldwin addr = frame->srr0;
254b53133a7SMateusz Guzik if (td->td_cowgen != atomic_load_int(&p->p_cowgen))
2554ea6a9a2SMateusz Guzik thread_cow_update(td);
25628cbb9b1SJustin Hibbits
25728cbb9b1SJustin Hibbits /* User Mode Traps */
25828cbb9b1SJustin Hibbits switch (type) {
25928cbb9b1SJustin Hibbits case EXC_RUNMODETRC:
26028cbb9b1SJustin Hibbits case EXC_TRC:
26128cbb9b1SJustin Hibbits frame->srr1 &= ~PSL_SE;
26228cbb9b1SJustin Hibbits sig = SIGTRAP;
26328cbb9b1SJustin Hibbits ucode = TRAP_TRACE;
26428cbb9b1SJustin Hibbits break;
26528cbb9b1SJustin Hibbits
266d5a30121SJustin Hibbits #if defined(__powerpc64__) && defined(AIM)
26728cbb9b1SJustin Hibbits case EXC_DSE:
2687d351d60SJohn Baldwin addr = frame->dar;
2697d351d60SJohn Baldwin /* FALLTHROUGH */
2707d351d60SJohn Baldwin case EXC_ISE:
27165bbba25SJustin Hibbits /* DSE/ISE are automatically fatal with radix pmap. */
27265bbba25SJustin Hibbits if (radix_mmu ||
27365bbba25SJustin Hibbits handle_user_slb_spill(&p->p_vmspace->vm_pmap,
2747d351d60SJohn Baldwin addr) != 0){
27528cbb9b1SJustin Hibbits sig = SIGSEGV;
27628cbb9b1SJustin Hibbits ucode = SEGV_MAPERR;
27728cbb9b1SJustin Hibbits }
27828cbb9b1SJustin Hibbits break;
27928cbb9b1SJustin Hibbits #endif
28028cbb9b1SJustin Hibbits case EXC_DSI:
2817d351d60SJohn Baldwin addr = frame->dar;
2827d351d60SJohn Baldwin /* FALLTHROUGH */
28328cbb9b1SJustin Hibbits case EXC_ISI:
284df08823dSKonstantin Belousov if (trap_pfault(frame, true, &sig, &ucode))
285df08823dSKonstantin Belousov sig = 0;
28628cbb9b1SJustin Hibbits break;
28728cbb9b1SJustin Hibbits
28828cbb9b1SJustin Hibbits case EXC_SC:
28928cbb9b1SJustin Hibbits syscall(frame);
29028cbb9b1SJustin Hibbits break;
29128cbb9b1SJustin Hibbits
29228cbb9b1SJustin Hibbits case EXC_FPU:
29328cbb9b1SJustin Hibbits KASSERT((td->td_pcb->pcb_flags & PCB_FPU) != PCB_FPU,
29428cbb9b1SJustin Hibbits ("FPU already enabled for thread"));
29528cbb9b1SJustin Hibbits enable_fpu(td);
29628cbb9b1SJustin Hibbits break;
29728cbb9b1SJustin Hibbits
29828cbb9b1SJustin Hibbits case EXC_VEC:
29928cbb9b1SJustin Hibbits KASSERT((td->td_pcb->pcb_flags & PCB_VEC) != PCB_VEC,
30028cbb9b1SJustin Hibbits ("Altivec already enabled for thread"));
30128cbb9b1SJustin Hibbits enable_vec(td);
30228cbb9b1SJustin Hibbits break;
30328cbb9b1SJustin Hibbits
30428cbb9b1SJustin Hibbits case EXC_VSX:
30528cbb9b1SJustin Hibbits KASSERT((td->td_pcb->pcb_flags & PCB_VSX) != PCB_VSX,
30628cbb9b1SJustin Hibbits ("VSX already enabled for thread"));
30728cbb9b1SJustin Hibbits if (!(td->td_pcb->pcb_flags & PCB_VEC))
30828cbb9b1SJustin Hibbits enable_vec(td);
309b501589dSLeandro Lupori if (td->td_pcb->pcb_flags & PCB_FPU)
31028cbb9b1SJustin Hibbits save_fpu(td);
31128cbb9b1SJustin Hibbits td->td_pcb->pcb_flags |= PCB_VSX;
31228cbb9b1SJustin Hibbits enable_fpu(td);
31328cbb9b1SJustin Hibbits break;
31428cbb9b1SJustin Hibbits
3157cd4e55cSJustin Hibbits case EXC_FAC:
316ac2605b1SJustin Hibbits fscr = mfspr(SPR_FSCR);
317d1d73b0eSJustin Hibbits switch (fscr & FSCR_IC_MASK) {
318d1d73b0eSJustin Hibbits case FSCR_IC_HTM:
319d1d73b0eSJustin Hibbits CTR0(KTR_TRAP,
320d1d73b0eSJustin Hibbits "Hardware Transactional Memory subsystem disabled");
321ac2605b1SJustin Hibbits sig = SIGILL;
322ac2605b1SJustin Hibbits ucode = ILL_ILLOPC;
323ac2605b1SJustin Hibbits break;
324d1d73b0eSJustin Hibbits case FSCR_IC_DSCR:
325d1d73b0eSJustin Hibbits td->td_pcb->pcb_flags |= PCB_CFSCR | PCB_CDSCR;
326d1d73b0eSJustin Hibbits fscr |= FSCR_DSCR;
327d1d73b0eSJustin Hibbits mtspr(SPR_DSCR, 0);
328d1d73b0eSJustin Hibbits break;
329d1d73b0eSJustin Hibbits case FSCR_IC_EBB:
330d1d73b0eSJustin Hibbits td->td_pcb->pcb_flags |= PCB_CFSCR;
331d1d73b0eSJustin Hibbits fscr |= FSCR_EBB;
332d1d73b0eSJustin Hibbits mtspr(SPR_EBBHR, 0);
333d1d73b0eSJustin Hibbits mtspr(SPR_EBBRR, 0);
334d1d73b0eSJustin Hibbits mtspr(SPR_BESCR, 0);
335d1d73b0eSJustin Hibbits break;
336d1d73b0eSJustin Hibbits case FSCR_IC_TAR:
337d1d73b0eSJustin Hibbits td->td_pcb->pcb_flags |= PCB_CFSCR;
338d1d73b0eSJustin Hibbits fscr |= FSCR_TAR;
339d1d73b0eSJustin Hibbits mtspr(SPR_TAR, 0);
340d1d73b0eSJustin Hibbits break;
341d1d73b0eSJustin Hibbits case FSCR_IC_LM:
342d1d73b0eSJustin Hibbits td->td_pcb->pcb_flags |= PCB_CFSCR;
343d1d73b0eSJustin Hibbits fscr |= FSCR_LM;
344d1d73b0eSJustin Hibbits mtspr(SPR_LMRR, 0);
345d1d73b0eSJustin Hibbits mtspr(SPR_LMSER, 0);
346d1d73b0eSJustin Hibbits break;
347d1d73b0eSJustin Hibbits default:
348d1d73b0eSJustin Hibbits sig = SIGILL;
349d1d73b0eSJustin Hibbits ucode = ILL_ILLOPC;
350d1d73b0eSJustin Hibbits }
351d1d73b0eSJustin Hibbits mtspr(SPR_FSCR, fscr & ~FSCR_IC_MASK);
352d1d73b0eSJustin Hibbits break;
353838070d5SWojciech Macek case EXC_HEA:
3547cd4e55cSJustin Hibbits sig = SIGILL;
3557cd4e55cSJustin Hibbits ucode = ILL_ILLOPC;
3567cd4e55cSJustin Hibbits break;
3577cd4e55cSJustin Hibbits
358541c5806SJustin Hibbits case EXC_VECAST_E:
35928cbb9b1SJustin Hibbits case EXC_VECAST_G4:
36028cbb9b1SJustin Hibbits case EXC_VECAST_G5:
36128cbb9b1SJustin Hibbits /*
36228cbb9b1SJustin Hibbits * We get a VPU assist exception for IEEE mode
36328cbb9b1SJustin Hibbits * vector operations on denormalized floats.
36428cbb9b1SJustin Hibbits * Emulating this is a giant pain, so for now,
36528cbb9b1SJustin Hibbits * just switch off IEEE mode and treat them as
36628cbb9b1SJustin Hibbits * zero.
36728cbb9b1SJustin Hibbits */
36828cbb9b1SJustin Hibbits
36928cbb9b1SJustin Hibbits save_vec(td);
37028cbb9b1SJustin Hibbits td->td_pcb->pcb_vec.vscr |= ALTIVEC_VSCR_NJ;
37128cbb9b1SJustin Hibbits enable_vec(td);
37228cbb9b1SJustin Hibbits break;
37328cbb9b1SJustin Hibbits
37428cbb9b1SJustin Hibbits case EXC_ALI:
37528cbb9b1SJustin Hibbits if (fix_unaligned(td, frame) != 0) {
37628cbb9b1SJustin Hibbits sig = SIGBUS;
37728cbb9b1SJustin Hibbits ucode = BUS_ADRALN;
3787d351d60SJohn Baldwin addr = frame->dar;
37928cbb9b1SJustin Hibbits }
38028cbb9b1SJustin Hibbits else
38128cbb9b1SJustin Hibbits frame->srr0 += 4;
38228cbb9b1SJustin Hibbits break;
38328cbb9b1SJustin Hibbits
38428cbb9b1SJustin Hibbits case EXC_DEBUG: /* Single stepping */
38528cbb9b1SJustin Hibbits mtspr(SPR_DBSR, mfspr(SPR_DBSR));
38628cbb9b1SJustin Hibbits frame->srr1 &= ~PSL_DE;
387fa133b6bSJustin Hibbits frame->cpu.booke.dbcr0 &= ~(DBCR0_IDM | DBCR0_IC);
38828cbb9b1SJustin Hibbits sig = SIGTRAP;
38928cbb9b1SJustin Hibbits ucode = TRAP_TRACE;
39028cbb9b1SJustin Hibbits break;
39128cbb9b1SJustin Hibbits
39228cbb9b1SJustin Hibbits case EXC_PGM:
39328cbb9b1SJustin Hibbits /* Identify the trap reason */
394a72b9513SJustin Hibbits if (frame_is_trap_inst(frame)) {
39528cbb9b1SJustin Hibbits #ifdef KDTRACE_HOOKS
39628cbb9b1SJustin Hibbits inst = fuword32((const void *)frame->srr0);
39728cbb9b1SJustin Hibbits if (inst == 0x0FFFDDDD &&
39828cbb9b1SJustin Hibbits dtrace_pid_probe_ptr != NULL) {
3995bab6234SMark Johnston (*dtrace_pid_probe_ptr)(frame);
40028cbb9b1SJustin Hibbits break;
40128cbb9b1SJustin Hibbits }
40228cbb9b1SJustin Hibbits #endif
40328cbb9b1SJustin Hibbits sig = SIGTRAP;
40428cbb9b1SJustin Hibbits ucode = TRAP_BRKPT;
4055d0e8619SAlfredo Dal'Ava Junior break;
4065d0e8619SAlfredo Dal'Ava Junior }
4075d0e8619SAlfredo Dal'Ava Junior
4085d0e8619SAlfredo Dal'Ava Junior if ((frame->srr1 & EXC_PGM_FPENABLED) &&
4095d0e8619SAlfredo Dal'Ava Junior (td->td_pcb->pcb_flags & PCB_FPU))
4105d0e8619SAlfredo Dal'Ava Junior sig = SIGFPE;
4115d0e8619SAlfredo Dal'Ava Junior else
41262c7ea1fSJustin Hibbits sig = ppc_instr_emulate(frame, td);
4135d0e8619SAlfredo Dal'Ava Junior
41428cbb9b1SJustin Hibbits if (sig == SIGILL) {
41528cbb9b1SJustin Hibbits if (frame->srr1 & EXC_PGM_PRIV)
41628cbb9b1SJustin Hibbits ucode = ILL_PRVOPC;
41728cbb9b1SJustin Hibbits else if (frame->srr1 & EXC_PGM_ILLEGAL)
41828cbb9b1SJustin Hibbits ucode = ILL_ILLOPC;
4195d0e8619SAlfredo Dal'Ava Junior } else if (sig == SIGFPE) {
4205d0e8619SAlfredo Dal'Ava Junior ucode = get_fpu_exception(td);
42128cbb9b1SJustin Hibbits }
4225d0e8619SAlfredo Dal'Ava Junior
42328cbb9b1SJustin Hibbits break;
42428cbb9b1SJustin Hibbits
42528cbb9b1SJustin Hibbits case EXC_MCHK:
42681962477SJustin Hibbits sig = cpu_machine_check(td, frame, &ucode);
42781962477SJustin Hibbits printtrap(frame->exc, frame, 0, (frame->srr1 & PSL_PR));
42828cbb9b1SJustin Hibbits break;
42928cbb9b1SJustin Hibbits
430be2bd024SLeandro Lupori #if defined(__powerpc64__) && defined(AIM)
431be2bd024SLeandro Lupori case EXC_SOFT_PATCH:
432be2bd024SLeandro Lupori /*
433be2bd024SLeandro Lupori * Point to the instruction that generated the exception to execute it again,
434be2bd024SLeandro Lupori * and normalize the register values.
435be2bd024SLeandro Lupori */
436be2bd024SLeandro Lupori frame->srr0 -= 4;
437be2bd024SLeandro Lupori normalize_inputs();
438be2bd024SLeandro Lupori break;
439be2bd024SLeandro Lupori #endif
440be2bd024SLeandro Lupori
44128cbb9b1SJustin Hibbits default:
44228cbb9b1SJustin Hibbits trap_fatal(frame);
44328cbb9b1SJustin Hibbits }
44428cbb9b1SJustin Hibbits } else {
44528cbb9b1SJustin Hibbits /* Kernel Mode Traps */
44628cbb9b1SJustin Hibbits
44728cbb9b1SJustin Hibbits KASSERT(cold || td->td_ucred != NULL,
44828cbb9b1SJustin Hibbits ("kernel trap doesn't have ucred"));
44928cbb9b1SJustin Hibbits switch (type) {
45028cbb9b1SJustin Hibbits case EXC_PGM:
45115fc4ab7SJustin Hibbits #ifdef KDTRACE_HOOKS
452a72b9513SJustin Hibbits if (frame_is_trap_inst(frame)) {
45328cbb9b1SJustin Hibbits if (*(uint32_t *)frame->srr0 == EXC_DTRACE) {
45428cbb9b1SJustin Hibbits if (dtrace_invop_jump_addr != NULL) {
45528cbb9b1SJustin Hibbits dtrace_invop_jump_addr(frame);
45628cbb9b1SJustin Hibbits return;
45728cbb9b1SJustin Hibbits }
45828cbb9b1SJustin Hibbits }
45928cbb9b1SJustin Hibbits }
46028cbb9b1SJustin Hibbits #endif
46115fc4ab7SJustin Hibbits #ifdef KDB
46215fc4ab7SJustin Hibbits if (db_trap_glue(frame))
46315fc4ab7SJustin Hibbits return;
46415fc4ab7SJustin Hibbits #endif
46515fc4ab7SJustin Hibbits break;
466d5a30121SJustin Hibbits #if defined(__powerpc64__) && defined(AIM)
46728cbb9b1SJustin Hibbits case EXC_DSE:
46865bbba25SJustin Hibbits /* DSE on radix mmu is automatically fatal. */
46965bbba25SJustin Hibbits if (radix_mmu)
47065bbba25SJustin Hibbits break;
471eb1baf72SNathan Whitehorn if (td->td_pcb->pcb_cpu.aim.usr_vsid != 0 &&
472eb1baf72SNathan Whitehorn (frame->dar & SEGMENT_MASK) == USER_ADDR) {
47328cbb9b1SJustin Hibbits __asm __volatile ("slbmte %0, %1" ::
47428cbb9b1SJustin Hibbits "r"(td->td_pcb->pcb_cpu.aim.usr_vsid),
47528cbb9b1SJustin Hibbits "r"(USER_SLB_SLBE));
47628cbb9b1SJustin Hibbits return;
47728cbb9b1SJustin Hibbits }
47828cbb9b1SJustin Hibbits break;
47928cbb9b1SJustin Hibbits #endif
48028cbb9b1SJustin Hibbits case EXC_DSI:
481df08823dSKonstantin Belousov if (trap_pfault(frame, false, NULL, NULL))
48228cbb9b1SJustin Hibbits return;
48328cbb9b1SJustin Hibbits break;
48428cbb9b1SJustin Hibbits case EXC_MCHK:
48528cbb9b1SJustin Hibbits if (handle_onfault(frame))
48628cbb9b1SJustin Hibbits return;
48728cbb9b1SJustin Hibbits break;
48828cbb9b1SJustin Hibbits default:
48928cbb9b1SJustin Hibbits break;
49028cbb9b1SJustin Hibbits }
49128cbb9b1SJustin Hibbits trap_fatal(frame);
49228cbb9b1SJustin Hibbits }
49328cbb9b1SJustin Hibbits
49428cbb9b1SJustin Hibbits if (sig != 0) {
49528cbb9b1SJustin Hibbits ksiginfo_init_trap(&ksi);
49628cbb9b1SJustin Hibbits ksi.ksi_signo = sig;
49728cbb9b1SJustin Hibbits ksi.ksi_code = (int) ucode; /* XXX, not POSIX */
4987d351d60SJohn Baldwin ksi.ksi_addr = (void *)addr;
49928cbb9b1SJustin Hibbits ksi.ksi_trapno = type;
5009470013fSAlfredo Dal'Ava Junior if (uprintf_signal) {
501e63daed1SAlfredo Dal'Ava Junior uprintf("pid %d comm %s: signal %d code %d type 0x%x "
5029470013fSAlfredo Dal'Ava Junior "addr 0x%lx r1 0x%lx srr0 0x%lx srr1 0x%lx\n",
5039470013fSAlfredo Dal'Ava Junior p->p_pid, p->p_comm, sig, ucode, type,
5049470013fSAlfredo Dal'Ava Junior (u_long)addr, (u_long)frame->fixreg[1],
5059470013fSAlfredo Dal'Ava Junior (u_long)frame->srr0, (u_long)frame->srr1);
5069470013fSAlfredo Dal'Ava Junior }
5079470013fSAlfredo Dal'Ava Junior
50828cbb9b1SJustin Hibbits trapsignal(td, &ksi);
50928cbb9b1SJustin Hibbits }
51028cbb9b1SJustin Hibbits
51128cbb9b1SJustin Hibbits userret(td, frame);
51228cbb9b1SJustin Hibbits }
51328cbb9b1SJustin Hibbits
51428cbb9b1SJustin Hibbits static void
trap_fatal(struct trapframe * frame)51528cbb9b1SJustin Hibbits trap_fatal(struct trapframe *frame)
51628cbb9b1SJustin Hibbits {
517f3f6ecb4SAndriy Gapon #ifdef KDB
518f3f6ecb4SAndriy Gapon bool handled;
519f3f6ecb4SAndriy Gapon #endif
52028cbb9b1SJustin Hibbits
52128cbb9b1SJustin Hibbits printtrap(frame->exc, frame, 1, (frame->srr1 & PSL_PR));
52228cbb9b1SJustin Hibbits #ifdef KDB
523b317cfd4SJohn Baldwin if (debugger_on_trap) {
524f3f6ecb4SAndriy Gapon kdb_why = KDB_WHY_TRAP;
525f3f6ecb4SAndriy Gapon handled = kdb_trap(frame->exc, 0, frame);
526f3f6ecb4SAndriy Gapon kdb_why = KDB_WHY_UNSET;
527f3f6ecb4SAndriy Gapon if (handled)
52828cbb9b1SJustin Hibbits return;
529f3f6ecb4SAndriy Gapon }
53028cbb9b1SJustin Hibbits #endif
53128cbb9b1SJustin Hibbits panic("%s trap", trapname(frame->exc));
53228cbb9b1SJustin Hibbits }
53328cbb9b1SJustin Hibbits
53428cbb9b1SJustin Hibbits static void
cpu_printtrap(u_int vector,struct trapframe * frame,int isfatal,int user)535fcc491a3SJustin Hibbits cpu_printtrap(u_int vector, struct trapframe *frame, int isfatal, int user)
536fcc491a3SJustin Hibbits {
537fcc491a3SJustin Hibbits #ifdef AIM
538fcc491a3SJustin Hibbits uint16_t ver;
539fcc491a3SJustin Hibbits
540fcc491a3SJustin Hibbits switch (vector) {
541fcc491a3SJustin Hibbits case EXC_MCHK:
542fcc491a3SJustin Hibbits ver = mfpvr() >> 16;
543fcc491a3SJustin Hibbits if (MPC745X_P(ver))
544fcc491a3SJustin Hibbits printf(" msssr0 = 0x%b\n",
545fcc491a3SJustin Hibbits (int)mfspr(SPR_MSSSR0), MSSSR_BITMASK);
54681962477SJustin Hibbits case EXC_DSE:
54781962477SJustin Hibbits case EXC_DSI:
54881962477SJustin Hibbits case EXC_DTMISS:
54981962477SJustin Hibbits printf(" dsisr = 0x%lx\n",
55081962477SJustin Hibbits (u_long)frame->cpu.aim.dsisr);
551fcc491a3SJustin Hibbits break;
552fcc491a3SJustin Hibbits }
553fcc491a3SJustin Hibbits #elif defined(BOOKE)
554fcc491a3SJustin Hibbits vm_paddr_t pa;
555fcc491a3SJustin Hibbits
556fcc491a3SJustin Hibbits switch (vector) {
557fcc491a3SJustin Hibbits case EXC_MCHK:
558fcc491a3SJustin Hibbits pa = mfspr(SPR_MCARU);
559fcc491a3SJustin Hibbits pa = (pa << 32) | (u_register_t)mfspr(SPR_MCAR);
560fcc491a3SJustin Hibbits printf(" mcsr = 0x%b\n",
561fcc491a3SJustin Hibbits (int)mfspr(SPR_MCSR), MCSR_BITMASK);
562fcc491a3SJustin Hibbits printf(" mcar = 0x%jx\n", (uintmax_t)pa);
563fcc491a3SJustin Hibbits }
564fcc491a3SJustin Hibbits printf(" esr = 0x%b\n",
565fcc491a3SJustin Hibbits (int)frame->cpu.booke.esr, ESR_BITMASK);
566fcc491a3SJustin Hibbits #endif
567fcc491a3SJustin Hibbits }
568fcc491a3SJustin Hibbits
569fcc491a3SJustin Hibbits static void
printtrap(u_int vector,struct trapframe * frame,int isfatal,int user)57028cbb9b1SJustin Hibbits printtrap(u_int vector, struct trapframe *frame, int isfatal, int user)
57128cbb9b1SJustin Hibbits {
57228cbb9b1SJustin Hibbits
57328cbb9b1SJustin Hibbits printf("\n");
57428cbb9b1SJustin Hibbits printf("%s %s trap:\n", isfatal ? "fatal" : "handled",
57528cbb9b1SJustin Hibbits user ? "user" : "kernel");
57628cbb9b1SJustin Hibbits printf("\n");
57728cbb9b1SJustin Hibbits printf(" exception = 0x%x (%s)\n", vector, trapname(vector));
57828cbb9b1SJustin Hibbits switch (vector) {
57928cbb9b1SJustin Hibbits case EXC_DSE:
58028cbb9b1SJustin Hibbits case EXC_DSI:
58139a4b70fSJustin Hibbits case EXC_DTMISS:
582b2c82073SJustin Hibbits case EXC_ALI:
58381962477SJustin Hibbits case EXC_MCHK:
58428cbb9b1SJustin Hibbits printf(" virtual address = 0x%" PRIxPTR "\n", frame->dar);
58528cbb9b1SJustin Hibbits break;
58628cbb9b1SJustin Hibbits case EXC_ISE:
58728cbb9b1SJustin Hibbits case EXC_ISI:
58839a4b70fSJustin Hibbits case EXC_ITMISS:
58928cbb9b1SJustin Hibbits printf(" virtual address = 0x%" PRIxPTR "\n", frame->srr0);
59028cbb9b1SJustin Hibbits break;
59128cbb9b1SJustin Hibbits }
592fcc491a3SJustin Hibbits cpu_printtrap(vector, frame, isfatal, user);
593ec75f647SNathan Whitehorn printf(" srr0 = 0x%" PRIxPTR " (0x%" PRIxPTR ")\n",
5944e05ac24SNathan Whitehorn frame->srr0, frame->srr0 - (register_t)(__startkernel - KERNBASE));
595cf5aa326SJustin Hibbits printf(" srr1 = 0x%lx\n", (u_long)frame->srr1);
5963762bafaSJustin Hibbits printf(" current msr = 0x%" PRIxPTR "\n", mfmsr());
597ec75f647SNathan Whitehorn printf(" lr = 0x%" PRIxPTR " (0x%" PRIxPTR ")\n",
5984e05ac24SNathan Whitehorn frame->lr, frame->lr - (register_t)(__startkernel - KERNBASE));
59966306e6aSJustin Hibbits printf(" frame = %p\n", frame);
60028cbb9b1SJustin Hibbits printf(" curthread = %p\n", curthread);
60128cbb9b1SJustin Hibbits if (curthread != NULL)
60228cbb9b1SJustin Hibbits printf(" pid = %d, comm = %s\n",
60328cbb9b1SJustin Hibbits curthread->td_proc->p_pid, curthread->td_name);
60428cbb9b1SJustin Hibbits printf("\n");
60528cbb9b1SJustin Hibbits }
60628cbb9b1SJustin Hibbits
60728cbb9b1SJustin Hibbits /*
60828cbb9b1SJustin Hibbits * Handles a fatal fault when we have onfault state to recover. Returns
60928cbb9b1SJustin Hibbits * non-zero if there was onfault recovery state available.
61028cbb9b1SJustin Hibbits */
61128cbb9b1SJustin Hibbits static int
handle_onfault(struct trapframe * frame)61228cbb9b1SJustin Hibbits handle_onfault(struct trapframe *frame)
61328cbb9b1SJustin Hibbits {
61428cbb9b1SJustin Hibbits struct thread *td;
615a18c313eSNathan Whitehorn jmp_buf *fb;
61628cbb9b1SJustin Hibbits
61728cbb9b1SJustin Hibbits td = curthread;
618d3111144SJustin Hibbits #if defined(__powerpc64__) || defined(BOOKE)
619d3111144SJustin Hibbits uintptr_t dispatch = (uintptr_t)td->td_pcb->pcb_onfault;
620d3111144SJustin Hibbits
621d3111144SJustin Hibbits if (dispatch == 0)
622d3111144SJustin Hibbits return (0);
623d3111144SJustin Hibbits /* Short-circuit radix and Book-E paths. */
624d3111144SJustin Hibbits switch (dispatch) {
625d3111144SJustin Hibbits case COPYFAULT:
626d3111144SJustin Hibbits frame->srr0 = (uintptr_t)copy_fault;
627d3111144SJustin Hibbits return (1);
628d3111144SJustin Hibbits case FUSUFAULT:
629d3111144SJustin Hibbits frame->srr0 = (uintptr_t)fusufault;
630d3111144SJustin Hibbits return (1);
631d3111144SJustin Hibbits default:
632d3111144SJustin Hibbits break;
633d3111144SJustin Hibbits }
634d3111144SJustin Hibbits #endif
63528cbb9b1SJustin Hibbits fb = td->td_pcb->pcb_onfault;
63628cbb9b1SJustin Hibbits if (fb != NULL) {
637a18c313eSNathan Whitehorn frame->srr0 = (*fb)->_jb[FAULTBUF_LR];
638a18c313eSNathan Whitehorn frame->fixreg[1] = (*fb)->_jb[FAULTBUF_R1];
639a18c313eSNathan Whitehorn frame->fixreg[2] = (*fb)->_jb[FAULTBUF_R2];
64028cbb9b1SJustin Hibbits frame->fixreg[3] = 1;
641a18c313eSNathan Whitehorn frame->cr = (*fb)->_jb[FAULTBUF_CR];
642a18c313eSNathan Whitehorn bcopy(&(*fb)->_jb[FAULTBUF_R14], &frame->fixreg[14],
643a18c313eSNathan Whitehorn 18 * sizeof(register_t));
644a18c313eSNathan Whitehorn td->td_pcb->pcb_onfault = NULL; /* Returns twice, not thrice */
64528cbb9b1SJustin Hibbits return (1);
64628cbb9b1SJustin Hibbits }
64728cbb9b1SJustin Hibbits return (0);
64828cbb9b1SJustin Hibbits }
64928cbb9b1SJustin Hibbits
65028cbb9b1SJustin Hibbits int
cpu_fetch_syscall_args(struct thread * td)6512d88da2fSKonstantin Belousov cpu_fetch_syscall_args(struct thread *td)
65228cbb9b1SJustin Hibbits {
65328cbb9b1SJustin Hibbits struct proc *p;
65428cbb9b1SJustin Hibbits struct trapframe *frame;
6552d88da2fSKonstantin Belousov struct syscall_args *sa;
65628cbb9b1SJustin Hibbits caddr_t params;
65728cbb9b1SJustin Hibbits size_t argsz;
6581e2521ffSEdward Tomasz Napierala int error, n, narg, i;
65928cbb9b1SJustin Hibbits
66028cbb9b1SJustin Hibbits p = td->td_proc;
66128cbb9b1SJustin Hibbits frame = td->td_frame;
6622d88da2fSKonstantin Belousov sa = &td->td_sa;
66328cbb9b1SJustin Hibbits
66428cbb9b1SJustin Hibbits sa->code = frame->fixreg[0];
665cf98bc28SDavid Chisnall sa->original_code = sa->code;
66628cbb9b1SJustin Hibbits params = (caddr_t)(frame->fixreg + FIRSTARG);
66728cbb9b1SJustin Hibbits n = NARGREG;
66828cbb9b1SJustin Hibbits
66928cbb9b1SJustin Hibbits if (sa->code == SYS_syscall) {
67028cbb9b1SJustin Hibbits /*
67128cbb9b1SJustin Hibbits * code is first argument,
67228cbb9b1SJustin Hibbits * followed by actual args.
67328cbb9b1SJustin Hibbits */
67428cbb9b1SJustin Hibbits sa->code = *(register_t *) params;
67528cbb9b1SJustin Hibbits params += sizeof(register_t);
67628cbb9b1SJustin Hibbits n -= 1;
67728cbb9b1SJustin Hibbits } else if (sa->code == SYS___syscall) {
67828cbb9b1SJustin Hibbits /*
67928cbb9b1SJustin Hibbits * Like syscall, but code is a quad,
68028cbb9b1SJustin Hibbits * so as to maintain quad alignment
68128cbb9b1SJustin Hibbits * for the rest of the args.
68228cbb9b1SJustin Hibbits */
68328cbb9b1SJustin Hibbits if (SV_PROC_FLAG(p, SV_ILP32)) {
68428cbb9b1SJustin Hibbits params += sizeof(register_t);
68528cbb9b1SJustin Hibbits sa->code = *(register_t *) params;
68628cbb9b1SJustin Hibbits params += sizeof(register_t);
68728cbb9b1SJustin Hibbits n -= 2;
68828cbb9b1SJustin Hibbits } else {
68928cbb9b1SJustin Hibbits sa->code = *(register_t *) params;
69028cbb9b1SJustin Hibbits params += sizeof(register_t);
69128cbb9b1SJustin Hibbits n -= 1;
69228cbb9b1SJustin Hibbits }
69328cbb9b1SJustin Hibbits }
69428cbb9b1SJustin Hibbits
69528cbb9b1SJustin Hibbits if (sa->code >= p->p_sysent->sv_size)
696*39024a89SKonstantin Belousov sa->callp = &nosys_sysent;
69728cbb9b1SJustin Hibbits else
69828cbb9b1SJustin Hibbits sa->callp = &p->p_sysent->sv_table[sa->code];
69928cbb9b1SJustin Hibbits
7001e2521ffSEdward Tomasz Napierala narg = sa->callp->sy_narg;
70128cbb9b1SJustin Hibbits
70228cbb9b1SJustin Hibbits if (SV_PROC_FLAG(p, SV_ILP32)) {
70328cbb9b1SJustin Hibbits argsz = sizeof(uint32_t);
70428cbb9b1SJustin Hibbits
70528cbb9b1SJustin Hibbits for (i = 0; i < n; i++)
70628cbb9b1SJustin Hibbits sa->args[i] = ((u_register_t *)(params))[i] &
70728cbb9b1SJustin Hibbits 0xffffffff;
70828cbb9b1SJustin Hibbits } else {
70928cbb9b1SJustin Hibbits argsz = sizeof(uint64_t);
71028cbb9b1SJustin Hibbits
71128cbb9b1SJustin Hibbits for (i = 0; i < n; i++)
71228cbb9b1SJustin Hibbits sa->args[i] = ((u_register_t *)(params))[i];
71328cbb9b1SJustin Hibbits }
71428cbb9b1SJustin Hibbits
7151e2521ffSEdward Tomasz Napierala if (narg > n)
71628cbb9b1SJustin Hibbits error = copyin(MOREARGS(frame->fixreg[1]), sa->args + n,
7171e2521ffSEdward Tomasz Napierala (narg - n) * argsz);
71828cbb9b1SJustin Hibbits else
71928cbb9b1SJustin Hibbits error = 0;
72028cbb9b1SJustin Hibbits
72128cbb9b1SJustin Hibbits #ifdef __powerpc64__
7221e2521ffSEdward Tomasz Napierala if (SV_PROC_FLAG(p, SV_ILP32) && narg > n) {
72328cbb9b1SJustin Hibbits /* Expand the size of arguments copied from the stack */
72428cbb9b1SJustin Hibbits
7251e2521ffSEdward Tomasz Napierala for (i = narg; i >= n; i--)
72628cbb9b1SJustin Hibbits sa->args[i] = ((uint32_t *)(&sa->args[n]))[i-n];
72728cbb9b1SJustin Hibbits }
72828cbb9b1SJustin Hibbits #endif
72928cbb9b1SJustin Hibbits
73028cbb9b1SJustin Hibbits if (error == 0) {
73128cbb9b1SJustin Hibbits td->td_retval[0] = 0;
73228cbb9b1SJustin Hibbits td->td_retval[1] = frame->fixreg[FIRSTARG + 1];
73328cbb9b1SJustin Hibbits }
73428cbb9b1SJustin Hibbits return (error);
73528cbb9b1SJustin Hibbits }
73628cbb9b1SJustin Hibbits
73728cbb9b1SJustin Hibbits #include "../../kern/subr_syscall.c"
73828cbb9b1SJustin Hibbits
73928cbb9b1SJustin Hibbits void
syscall(struct trapframe * frame)74028cbb9b1SJustin Hibbits syscall(struct trapframe *frame)
74128cbb9b1SJustin Hibbits {
74228cbb9b1SJustin Hibbits struct thread *td;
74328cbb9b1SJustin Hibbits
74428cbb9b1SJustin Hibbits td = curthread;
74528cbb9b1SJustin Hibbits td->td_frame = frame;
74628cbb9b1SJustin Hibbits
747d5a30121SJustin Hibbits #if defined(__powerpc64__) && defined(AIM)
74828cbb9b1SJustin Hibbits /*
74928cbb9b1SJustin Hibbits * Speculatively restore last user SLB segment, which we know is
75028cbb9b1SJustin Hibbits * invalid already, since we are likely to do copyin()/copyout().
75128cbb9b1SJustin Hibbits */
752e649493cSNathan Whitehorn if (td->td_pcb->pcb_cpu.aim.usr_vsid != 0)
75328cbb9b1SJustin Hibbits __asm __volatile ("slbmte %0, %1; isync" ::
75428cbb9b1SJustin Hibbits "r"(td->td_pcb->pcb_cpu.aim.usr_vsid), "r"(USER_SLB_SLBE));
75528cbb9b1SJustin Hibbits #endif
75628cbb9b1SJustin Hibbits
757c18ca749SJohn Baldwin syscallenter(td);
758c18ca749SJohn Baldwin syscallret(td);
75928cbb9b1SJustin Hibbits }
76028cbb9b1SJustin Hibbits
761df08823dSKonstantin Belousov static bool
trap_pfault(struct trapframe * frame,bool user,int * signo,int * ucode)762df08823dSKonstantin Belousov trap_pfault(struct trapframe *frame, bool user, int *signo, int *ucode)
76328cbb9b1SJustin Hibbits {
764df08823dSKonstantin Belousov vm_offset_t eva;
76528cbb9b1SJustin Hibbits struct thread *td;
76628cbb9b1SJustin Hibbits struct proc *p;
76728cbb9b1SJustin Hibbits vm_map_t map;
76828cbb9b1SJustin Hibbits vm_prot_t ftype;
769eb1baf72SNathan Whitehorn int rv, is_user;
77028cbb9b1SJustin Hibbits
77128cbb9b1SJustin Hibbits td = curthread;
77228cbb9b1SJustin Hibbits p = td->td_proc;
77328cbb9b1SJustin Hibbits if (frame->exc == EXC_ISI) {
77428cbb9b1SJustin Hibbits eva = frame->srr0;
77528cbb9b1SJustin Hibbits ftype = VM_PROT_EXECUTE;
77628cbb9b1SJustin Hibbits if (frame->srr1 & SRR1_ISI_PFAULT)
77728cbb9b1SJustin Hibbits ftype |= VM_PROT_READ;
77828cbb9b1SJustin Hibbits } else {
77928cbb9b1SJustin Hibbits eva = frame->dar;
78028cbb9b1SJustin Hibbits #ifdef BOOKE
78128cbb9b1SJustin Hibbits if (frame->cpu.booke.esr & ESR_ST)
78228cbb9b1SJustin Hibbits #else
78328cbb9b1SJustin Hibbits if (frame->cpu.aim.dsisr & DSISR_STORE)
78428cbb9b1SJustin Hibbits #endif
78528cbb9b1SJustin Hibbits ftype = VM_PROT_WRITE;
78628cbb9b1SJustin Hibbits else
78728cbb9b1SJustin Hibbits ftype = VM_PROT_READ;
78828cbb9b1SJustin Hibbits }
78965bbba25SJustin Hibbits #if defined(__powerpc64__) && defined(AIM)
79065bbba25SJustin Hibbits if (radix_mmu && pmap_nofault(&p->p_vmspace->vm_pmap, eva, ftype) == 0)
79165bbba25SJustin Hibbits return (true);
79265bbba25SJustin Hibbits #endif
79328cbb9b1SJustin Hibbits
79465bbba25SJustin Hibbits if (__predict_false((td->td_pflags & TDP_NOFAULTING) == 0)) {
79565bbba25SJustin Hibbits /*
79665bbba25SJustin Hibbits * If we get a page fault while in a critical section, then
79765bbba25SJustin Hibbits * it is most likely a fatal kernel page fault. The kernel
79865bbba25SJustin Hibbits * is already going to panic trying to get a sleep lock to
79965bbba25SJustin Hibbits * do the VM lookup, so just consider it a fatal trap so the
80065bbba25SJustin Hibbits * kernel can print out a useful trap message and even get
80165bbba25SJustin Hibbits * to the debugger.
80265bbba25SJustin Hibbits *
80365bbba25SJustin Hibbits * If we get a page fault while holding a non-sleepable
80465bbba25SJustin Hibbits * lock, then it is most likely a fatal kernel page fault.
80565bbba25SJustin Hibbits * If WITNESS is enabled, then it's going to whine about
80665bbba25SJustin Hibbits * bogus LORs with various VM locks, so just skip to the
80765bbba25SJustin Hibbits * fatal trap handling directly.
80865bbba25SJustin Hibbits */
80965bbba25SJustin Hibbits if (td->td_critnest != 0 ||
81065bbba25SJustin Hibbits WITNESS_CHECK(WARN_SLEEPOK | WARN_GIANTOK, NULL,
81165bbba25SJustin Hibbits "Kernel page fault") != 0) {
81265bbba25SJustin Hibbits trap_fatal(frame);
81365bbba25SJustin Hibbits return (false);
81465bbba25SJustin Hibbits }
81565bbba25SJustin Hibbits }
81628cbb9b1SJustin Hibbits if (user) {
81728cbb9b1SJustin Hibbits KASSERT(p->p_vmspace != NULL, ("trap_pfault: vmspace NULL"));
81828cbb9b1SJustin Hibbits map = &p->p_vmspace->vm_map;
81928cbb9b1SJustin Hibbits } else {
820eb1baf72SNathan Whitehorn rv = pmap_decode_kernel_ptr(eva, &is_user, &eva);
821eb1baf72SNathan Whitehorn if (rv != 0)
822df08823dSKonstantin Belousov return (false);
82328cbb9b1SJustin Hibbits
824eb1baf72SNathan Whitehorn if (is_user)
825eb1baf72SNathan Whitehorn map = &p->p_vmspace->vm_map;
826eb1baf72SNathan Whitehorn else
82728cbb9b1SJustin Hibbits map = kernel_map;
82828cbb9b1SJustin Hibbits }
82928cbb9b1SJustin Hibbits
8301fa67124SKonstantin Belousov /* Fault in the page. */
831df08823dSKonstantin Belousov rv = vm_fault_trap(map, eva, ftype, VM_FAULT_NORMAL, signo, ucode);
83228cbb9b1SJustin Hibbits /*
83328cbb9b1SJustin Hibbits * XXXDTRACE: add dtrace_doubletrap_func here?
83428cbb9b1SJustin Hibbits */
83528cbb9b1SJustin Hibbits
83628cbb9b1SJustin Hibbits if (rv == KERN_SUCCESS)
837df08823dSKonstantin Belousov return (true);
83828cbb9b1SJustin Hibbits
83928cbb9b1SJustin Hibbits if (!user && handle_onfault(frame))
840df08823dSKonstantin Belousov return (true);
84128cbb9b1SJustin Hibbits
842df08823dSKonstantin Belousov return (false);
84328cbb9b1SJustin Hibbits }
84428cbb9b1SJustin Hibbits
84528cbb9b1SJustin Hibbits /*
84628cbb9b1SJustin Hibbits * For now, this only deals with the particular unaligned access case
84728cbb9b1SJustin Hibbits * that gcc tends to generate. Eventually it should handle all of the
84828cbb9b1SJustin Hibbits * possibilities that can happen on a 32-bit PowerPC in big-endian mode.
84928cbb9b1SJustin Hibbits */
85028cbb9b1SJustin Hibbits
85128cbb9b1SJustin Hibbits static int
fix_unaligned(struct thread * td,struct trapframe * frame)85228cbb9b1SJustin Hibbits fix_unaligned(struct thread *td, struct trapframe *frame)
85328cbb9b1SJustin Hibbits {
85428cbb9b1SJustin Hibbits struct thread *fputhread;
855088c26aeSJustin Hibbits #ifdef BOOKE
856dc9b124dSJustin Hibbits uint32_t inst;
857dc9b124dSJustin Hibbits #endif
85828cbb9b1SJustin Hibbits int indicator, reg;
85928cbb9b1SJustin Hibbits double *fpr;
86028cbb9b1SJustin Hibbits
861dc9b124dSJustin Hibbits #ifdef __SPE__
862dc9b124dSJustin Hibbits indicator = (frame->cpu.booke.esr & (ESR_ST|ESR_SPE));
863dc9b124dSJustin Hibbits if (indicator & ESR_SPE) {
864dc9b124dSJustin Hibbits if (copyin((void *)frame->srr0, &inst, sizeof(inst)) != 0)
865dc9b124dSJustin Hibbits return (-1);
866088c26aeSJustin Hibbits reg = EXC_ALI_INST_RST(inst);
867dc9b124dSJustin Hibbits fpr = (double *)td->td_pcb->pcb_vec.vr[reg];
868dc9b124dSJustin Hibbits fputhread = PCPU_GET(vecthread);
869dc9b124dSJustin Hibbits
87089965e70SJustin Hibbits /* Juggle the SPE to ensure that we've initialized
87189965e70SJustin Hibbits * the registers, and that their current state is in
872dc9b124dSJustin Hibbits * the PCB.
873dc9b124dSJustin Hibbits */
874eaa5e396SJustin Hibbits if (fputhread != td) {
875eaa5e396SJustin Hibbits if (fputhread)
876eaa5e396SJustin Hibbits save_vec(fputhread);
877dc9b124dSJustin Hibbits enable_vec(td);
878dc9b124dSJustin Hibbits }
879dc9b124dSJustin Hibbits save_vec(td);
880dc9b124dSJustin Hibbits
881dc9b124dSJustin Hibbits if (!(indicator & ESR_ST)) {
882dc9b124dSJustin Hibbits if (copyin((void *)frame->dar, fpr,
883dc9b124dSJustin Hibbits sizeof(double)) != 0)
884dc9b124dSJustin Hibbits return (-1);
885dc9b124dSJustin Hibbits frame->fixreg[reg] = td->td_pcb->pcb_vec.vr[reg][1];
886dc9b124dSJustin Hibbits enable_vec(td);
887dc9b124dSJustin Hibbits } else {
888dc9b124dSJustin Hibbits td->td_pcb->pcb_vec.vr[reg][1] = frame->fixreg[reg];
889dc9b124dSJustin Hibbits if (copyout(fpr, (void *)frame->dar,
890dc9b124dSJustin Hibbits sizeof(double)) != 0)
891dc9b124dSJustin Hibbits return (-1);
892dc9b124dSJustin Hibbits }
893dc9b124dSJustin Hibbits return (0);
894dc9b124dSJustin Hibbits }
895dc9b124dSJustin Hibbits #else
896088c26aeSJustin Hibbits #ifdef BOOKE
897088c26aeSJustin Hibbits indicator = (frame->cpu.booke.esr & ESR_ST) ? EXC_ALI_STFD : EXC_ALI_LFD;
898088c26aeSJustin Hibbits #else
89928cbb9b1SJustin Hibbits indicator = EXC_ALI_OPCODE_INDICATOR(frame->cpu.aim.dsisr);
900088c26aeSJustin Hibbits #endif
90128cbb9b1SJustin Hibbits
90228cbb9b1SJustin Hibbits switch (indicator) {
90328cbb9b1SJustin Hibbits case EXC_ALI_LFD:
90428cbb9b1SJustin Hibbits case EXC_ALI_STFD:
905088c26aeSJustin Hibbits #ifdef BOOKE
906088c26aeSJustin Hibbits if (copyin((void *)frame->srr0, &inst, sizeof(inst)) != 0)
907088c26aeSJustin Hibbits return (-1);
908088c26aeSJustin Hibbits reg = EXC_ALI_INST_RST(inst);
909088c26aeSJustin Hibbits #else
91028cbb9b1SJustin Hibbits reg = EXC_ALI_RST(frame->cpu.aim.dsisr);
911088c26aeSJustin Hibbits #endif
91228cbb9b1SJustin Hibbits fpr = &td->td_pcb->pcb_fpu.fpr[reg].fpr;
91328cbb9b1SJustin Hibbits fputhread = PCPU_GET(fputhread);
91428cbb9b1SJustin Hibbits
91528cbb9b1SJustin Hibbits /* Juggle the FPU to ensure that we've initialized
91628cbb9b1SJustin Hibbits * the FPRs, and that their current state is in
91728cbb9b1SJustin Hibbits * the PCB.
91828cbb9b1SJustin Hibbits */
91928cbb9b1SJustin Hibbits if (fputhread != td) {
92028cbb9b1SJustin Hibbits if (fputhread)
92128cbb9b1SJustin Hibbits save_fpu(fputhread);
92228cbb9b1SJustin Hibbits enable_fpu(td);
92328cbb9b1SJustin Hibbits }
92428cbb9b1SJustin Hibbits save_fpu(td);
92528cbb9b1SJustin Hibbits
92628cbb9b1SJustin Hibbits if (indicator == EXC_ALI_LFD) {
92728cbb9b1SJustin Hibbits if (copyin((void *)frame->dar, fpr,
92828cbb9b1SJustin Hibbits sizeof(double)) != 0)
92928cbb9b1SJustin Hibbits return (-1);
93028cbb9b1SJustin Hibbits enable_fpu(td);
93128cbb9b1SJustin Hibbits } else {
93228cbb9b1SJustin Hibbits if (copyout(fpr, (void *)frame->dar,
93328cbb9b1SJustin Hibbits sizeof(double)) != 0)
93428cbb9b1SJustin Hibbits return (-1);
93528cbb9b1SJustin Hibbits }
93628cbb9b1SJustin Hibbits return (0);
93728cbb9b1SJustin Hibbits break;
93828cbb9b1SJustin Hibbits }
939dc9b124dSJustin Hibbits #endif
94028cbb9b1SJustin Hibbits
94128cbb9b1SJustin Hibbits return (-1);
94228cbb9b1SJustin Hibbits }
94328cbb9b1SJustin Hibbits
944be2bd024SLeandro Lupori #if defined(__powerpc64__) && defined(AIM)
945be2bd024SLeandro Lupori #define MSKNSHL(x, m, n) "(((" #x ") & " #m ") << " #n ")"
946be2bd024SLeandro Lupori #define MSKNSHR(x, m, n) "(((" #x ") & " #m ") >> " #n ")"
947be2bd024SLeandro Lupori
948be2bd024SLeandro Lupori /* xvcpsgndp instruction, built in opcode format.
949be2bd024SLeandro Lupori * This can be changed to use mnemonic after a toolchain update.
950be2bd024SLeandro Lupori */
951be2bd024SLeandro Lupori #define XVCPSGNDP(xt, xa, xb) \
952be2bd024SLeandro Lupori __asm __volatile(".long (" \
953be2bd024SLeandro Lupori MSKNSHL(60, 0x3f, 26) " | " \
954be2bd024SLeandro Lupori MSKNSHL(xt, 0x1f, 21) " | " \
955be2bd024SLeandro Lupori MSKNSHL(xa, 0x1f, 16) " | " \
956be2bd024SLeandro Lupori MSKNSHL(xb, 0x1f, 11) " | " \
957be2bd024SLeandro Lupori MSKNSHL(240, 0xff, 3) " | " \
958be2bd024SLeandro Lupori MSKNSHR(xa, 0x20, 3) " | " \
959be2bd024SLeandro Lupori MSKNSHR(xa, 0x20, 4) " | " \
960be2bd024SLeandro Lupori MSKNSHR(xa, 0x20, 5) ")")
961be2bd024SLeandro Lupori
962be2bd024SLeandro Lupori /* Macros to normalize 1 or 10 VSX registers */
963be2bd024SLeandro Lupori #define NORM(x) XVCPSGNDP(x, x, x)
964be2bd024SLeandro Lupori #define NORM10(x) \
965be2bd024SLeandro Lupori NORM(x ## 0); NORM(x ## 1); NORM(x ## 2); NORM(x ## 3); NORM(x ## 4); \
966be2bd024SLeandro Lupori NORM(x ## 5); NORM(x ## 6); NORM(x ## 7); NORM(x ## 8); NORM(x ## 9)
967be2bd024SLeandro Lupori
968be2bd024SLeandro Lupori static void
normalize_inputs(void)969be2bd024SLeandro Lupori normalize_inputs(void)
970be2bd024SLeandro Lupori {
9715d0e8619SAlfredo Dal'Ava Junior register_t msr;
972be2bd024SLeandro Lupori
973be2bd024SLeandro Lupori /* enable VSX */
974be2bd024SLeandro Lupori msr = mfmsr();
975be2bd024SLeandro Lupori mtmsr(msr | PSL_VSX);
976be2bd024SLeandro Lupori
977be2bd024SLeandro Lupori NORM(0); NORM(1); NORM(2); NORM(3); NORM(4);
978be2bd024SLeandro Lupori NORM(5); NORM(6); NORM(7); NORM(8); NORM(9);
979be2bd024SLeandro Lupori NORM10(1); NORM10(2); NORM10(3); NORM10(4); NORM10(5);
980be2bd024SLeandro Lupori NORM(60); NORM(61); NORM(62); NORM(63);
981be2bd024SLeandro Lupori
982be2bd024SLeandro Lupori /* restore MSR */
983be2bd024SLeandro Lupori mtmsr(msr);
984be2bd024SLeandro Lupori }
985be2bd024SLeandro Lupori #endif
986be2bd024SLeandro Lupori
98728cbb9b1SJustin Hibbits #ifdef KDB
98828cbb9b1SJustin Hibbits int
db_trap_glue(struct trapframe * frame)98928cbb9b1SJustin Hibbits db_trap_glue(struct trapframe *frame)
99028cbb9b1SJustin Hibbits {
99115fc4ab7SJustin Hibbits
99228cbb9b1SJustin Hibbits if (!(frame->srr1 & PSL_PR)
99328cbb9b1SJustin Hibbits && (frame->exc == EXC_TRC || frame->exc == EXC_RUNMODETRC
994a72b9513SJustin Hibbits || frame_is_trap_inst(frame)
99528cbb9b1SJustin Hibbits || frame->exc == EXC_BPT
9969ae2eed9SJustin Hibbits || frame->exc == EXC_DEBUG
99728cbb9b1SJustin Hibbits || frame->exc == EXC_DSI)) {
99828cbb9b1SJustin Hibbits int type = frame->exc;
99928cbb9b1SJustin Hibbits
100028cbb9b1SJustin Hibbits /* Ignore DTrace traps. */
100128cbb9b1SJustin Hibbits if (*(uint32_t *)frame->srr0 == EXC_DTRACE)
100228cbb9b1SJustin Hibbits return (0);
1003a72b9513SJustin Hibbits if (frame_is_trap_inst(frame)) {
100428cbb9b1SJustin Hibbits type = T_BREAKPOINT;
100528cbb9b1SJustin Hibbits }
100628cbb9b1SJustin Hibbits return (kdb_trap(type, 0, frame));
100728cbb9b1SJustin Hibbits }
100828cbb9b1SJustin Hibbits
100928cbb9b1SJustin Hibbits return (0);
101028cbb9b1SJustin Hibbits }
101128cbb9b1SJustin Hibbits #endif
1012