1 /*- 2 * Copyright (c) 2015-2017 Ruslan Bukin <br@bsdpad.com> 3 * All rights reserved. 4 * 5 * Portions of this software were developed by SRI International and the 6 * University of Cambridge Computer Laboratory under DARPA/AFRL contract 7 * FA8750-10-C-0237 ("CTSRD"), as part of the DARPA CRASH research programme. 8 * 9 * Portions of this software were developed by the University of Cambridge 10 * Computer Laboratory as part of the CTSRD Project, with support from the 11 * UK Higher Education Innovation Fund (HEIF). 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 35 #include <sys/cdefs.h> 36 __FBSDID("$FreeBSD$"); 37 38 #include <sys/param.h> 39 #include <sys/systm.h> 40 #include <sys/kernel.h> 41 #include <sys/lock.h> 42 #include <sys/mutex.h> 43 #include <sys/pioctl.h> 44 #include <sys/bus.h> 45 #include <sys/proc.h> 46 #include <sys/ptrace.h> 47 #include <sys/syscall.h> 48 #include <sys/sysent.h> 49 #ifdef KDB 50 #include <sys/kdb.h> 51 #endif 52 53 #include <vm/vm.h> 54 #include <vm/pmap.h> 55 #include <vm/vm_kern.h> 56 #include <vm/vm_map.h> 57 #include <vm/vm_param.h> 58 #include <vm/vm_extern.h> 59 60 #include <machine/frame.h> 61 #include <machine/pcb.h> 62 #include <machine/pcpu.h> 63 64 #include <machine/resource.h> 65 #include <machine/intr.h> 66 67 #ifdef KDTRACE_HOOKS 68 #include <sys/dtrace_bsd.h> 69 #endif 70 71 int (*dtrace_invop_jump_addr)(struct trapframe *); 72 73 extern register_t fsu_intr_fault; 74 75 /* Called from exception.S */ 76 void do_trap_supervisor(struct trapframe *); 77 void do_trap_user(struct trapframe *); 78 79 static __inline void 80 call_trapsignal(struct thread *td, int sig, int code, void *addr) 81 { 82 ksiginfo_t ksi; 83 84 ksiginfo_init_trap(&ksi); 85 ksi.ksi_signo = sig; 86 ksi.ksi_code = code; 87 ksi.ksi_addr = addr; 88 trapsignal(td, &ksi); 89 } 90 91 int 92 cpu_fetch_syscall_args(struct thread *td) 93 { 94 struct proc *p; 95 register_t *ap; 96 struct syscall_args *sa; 97 int nap; 98 99 nap = NARGREG; 100 p = td->td_proc; 101 sa = &td->td_sa; 102 ap = &td->td_frame->tf_a[0]; 103 104 sa->code = td->td_frame->tf_t[0]; 105 106 if (sa->code == SYS_syscall || sa->code == SYS___syscall) { 107 sa->code = *ap++; 108 nap--; 109 } 110 111 if (p->p_sysent->sv_mask) 112 sa->code &= p->p_sysent->sv_mask; 113 if (sa->code >= p->p_sysent->sv_size) 114 sa->callp = &p->p_sysent->sv_table[0]; 115 else 116 sa->callp = &p->p_sysent->sv_table[sa->code]; 117 118 sa->narg = sa->callp->sy_narg; 119 memcpy(sa->args, ap, nap * sizeof(register_t)); 120 if (sa->narg > nap) 121 panic("TODO: Could we have more then %d args?", NARGREG); 122 123 td->td_retval[0] = 0; 124 td->td_retval[1] = 0; 125 126 return (0); 127 } 128 129 #include "../../kern/subr_syscall.c" 130 131 static void 132 dump_regs(struct trapframe *frame) 133 { 134 int n; 135 int i; 136 137 n = (sizeof(frame->tf_t) / sizeof(frame->tf_t[0])); 138 for (i = 0; i < n; i++) 139 printf("t[%d] == 0x%016lx\n", i, frame->tf_t[i]); 140 141 n = (sizeof(frame->tf_s) / sizeof(frame->tf_s[0])); 142 for (i = 0; i < n; i++) 143 printf("s[%d] == 0x%016lx\n", i, frame->tf_s[i]); 144 145 n = (sizeof(frame->tf_a) / sizeof(frame->tf_a[0])); 146 for (i = 0; i < n; i++) 147 printf("a[%d] == 0x%016lx\n", i, frame->tf_a[i]); 148 149 printf("sepc == 0x%016lx\n", frame->tf_sepc); 150 printf("sstatus == 0x%016lx\n", frame->tf_sstatus); 151 } 152 153 static void 154 svc_handler(struct trapframe *frame) 155 { 156 struct thread *td; 157 int error; 158 159 td = curthread; 160 td->td_frame = frame; 161 162 error = syscallenter(td); 163 syscallret(td, error); 164 } 165 166 static void 167 data_abort(struct trapframe *frame, int lower) 168 { 169 struct vm_map *map; 170 uint64_t sbadaddr; 171 struct thread *td; 172 struct pcb *pcb; 173 vm_prot_t ftype; 174 vm_offset_t va; 175 struct proc *p; 176 int ucode; 177 int error; 178 int sig; 179 180 #ifdef KDB 181 if (kdb_active) { 182 kdb_reenter(); 183 return; 184 } 185 #endif 186 187 td = curthread; 188 pcb = td->td_pcb; 189 sbadaddr = frame->tf_sbadaddr; 190 191 p = td->td_proc; 192 193 if (lower) 194 map = &td->td_proc->p_vmspace->vm_map; 195 else { 196 /* The top bit tells us which range to use */ 197 if ((sbadaddr >> 63) == 1) 198 map = kernel_map; 199 else 200 map = &td->td_proc->p_vmspace->vm_map; 201 } 202 203 va = trunc_page(sbadaddr); 204 205 if ((frame->tf_scause == EXCP_FAULT_STORE) || 206 (frame->tf_scause == EXCP_STORE_PAGE_FAULT)) { 207 ftype = (VM_PROT_READ | VM_PROT_WRITE); 208 } else { 209 ftype = (VM_PROT_READ); 210 } 211 212 if (map != kernel_map) { 213 /* 214 * Keep swapout from messing with us during this 215 * critical time. 216 */ 217 PROC_LOCK(p); 218 ++p->p_lock; 219 PROC_UNLOCK(p); 220 221 /* Fault in the user page: */ 222 error = vm_fault(map, va, ftype, VM_FAULT_NORMAL); 223 224 PROC_LOCK(p); 225 --p->p_lock; 226 PROC_UNLOCK(p); 227 } else { 228 /* 229 * Don't have to worry about process locking or stacks in the 230 * kernel. 231 */ 232 error = vm_fault(map, va, ftype, VM_FAULT_NORMAL); 233 } 234 235 if (error != KERN_SUCCESS) { 236 if (lower) { 237 sig = SIGSEGV; 238 if (error == KERN_PROTECTION_FAILURE) 239 ucode = SEGV_ACCERR; 240 else 241 ucode = SEGV_MAPERR; 242 call_trapsignal(td, sig, ucode, (void *)sbadaddr); 243 } else { 244 if (td->td_intr_nesting_level == 0 && 245 pcb->pcb_onfault != 0) { 246 frame->tf_a[0] = error; 247 frame->tf_sepc = pcb->pcb_onfault; 248 return; 249 } 250 dump_regs(frame); 251 panic("vm_fault failed: %lx, va 0x%016lx", 252 frame->tf_sepc, sbadaddr); 253 } 254 } 255 256 if (lower) 257 userret(td, frame); 258 } 259 260 void 261 do_trap_supervisor(struct trapframe *frame) 262 { 263 uint64_t exception; 264 uint64_t sstatus; 265 266 /* Ensure we came from supervisor mode, interrupts disabled */ 267 __asm __volatile("csrr %0, sstatus" : "=&r" (sstatus)); 268 KASSERT((sstatus & (SSTATUS_SPP | SSTATUS_SIE)) == SSTATUS_SPP, 269 ("We must came from S mode with interrupts disabled")); 270 271 exception = (frame->tf_scause & EXCP_MASK); 272 if (frame->tf_scause & EXCP_INTR) { 273 /* Interrupt */ 274 riscv_cpu_intr(frame); 275 return; 276 } 277 278 #ifdef KDTRACE_HOOKS 279 if (dtrace_trap_func != NULL && (*dtrace_trap_func)(frame, exception)) 280 return; 281 #endif 282 283 CTR3(KTR_TRAP, "do_trap_supervisor: curthread: %p, sepc: %lx, frame: %p", 284 curthread, frame->tf_sepc, frame); 285 286 switch(exception) { 287 case EXCP_FAULT_LOAD: 288 case EXCP_FAULT_STORE: 289 case EXCP_FAULT_FETCH: 290 case EXCP_STORE_PAGE_FAULT: 291 case EXCP_LOAD_PAGE_FAULT: 292 data_abort(frame, 0); 293 break; 294 case EXCP_BREAKPOINT: 295 #ifdef KDTRACE_HOOKS 296 if (dtrace_invop_jump_addr != 0) { 297 dtrace_invop_jump_addr(frame); 298 break; 299 } 300 #endif 301 #ifdef KDB 302 kdb_trap(exception, 0, frame); 303 #else 304 dump_regs(frame); 305 panic("No debugger in kernel.\n"); 306 #endif 307 break; 308 case EXCP_ILLEGAL_INSTRUCTION: 309 dump_regs(frame); 310 panic("Illegal instruction at 0x%016lx\n", frame->tf_sepc); 311 break; 312 default: 313 dump_regs(frame); 314 panic("Unknown kernel exception %x badaddr %lx\n", 315 exception, frame->tf_sbadaddr); 316 } 317 } 318 319 void 320 do_trap_user(struct trapframe *frame) 321 { 322 uint64_t exception; 323 struct thread *td; 324 uint64_t sstatus; 325 struct pcb *pcb; 326 327 td = curthread; 328 td->td_frame = frame; 329 pcb = td->td_pcb; 330 331 /* Ensure we came from usermode, interrupts disabled */ 332 __asm __volatile("csrr %0, sstatus" : "=&r" (sstatus)); 333 KASSERT((sstatus & (SSTATUS_SPP | SSTATUS_SIE)) == 0, 334 ("We must came from U mode with interrupts disabled")); 335 336 exception = (frame->tf_scause & EXCP_MASK); 337 if (frame->tf_scause & EXCP_INTR) { 338 /* Interrupt */ 339 riscv_cpu_intr(frame); 340 return; 341 } 342 343 CTR3(KTR_TRAP, "do_trap_user: curthread: %p, sepc: %lx, frame: %p", 344 curthread, frame->tf_sepc, frame); 345 346 switch(exception) { 347 case EXCP_FAULT_LOAD: 348 case EXCP_FAULT_STORE: 349 case EXCP_FAULT_FETCH: 350 case EXCP_STORE_PAGE_FAULT: 351 case EXCP_LOAD_PAGE_FAULT: 352 case EXCP_INST_PAGE_FAULT: 353 data_abort(frame, 1); 354 break; 355 case EXCP_USER_ECALL: 356 frame->tf_sepc += 4; /* Next instruction */ 357 svc_handler(frame); 358 break; 359 case EXCP_ILLEGAL_INSTRUCTION: 360 #ifdef FPE 361 if ((pcb->pcb_fpflags & PCB_FP_STARTED) == 0) { 362 /* 363 * May be a FPE trap. Enable FPE usage 364 * for this thread and try again. 365 */ 366 frame->tf_sstatus |= SSTATUS_FS_INITIAL; 367 pcb->pcb_fpflags |= PCB_FP_STARTED; 368 break; 369 } 370 #endif 371 call_trapsignal(td, SIGILL, ILL_ILLTRP, (void *)frame->tf_sepc); 372 userret(td, frame); 373 break; 374 case EXCP_BREAKPOINT: 375 call_trapsignal(td, SIGTRAP, TRAP_BRKPT, (void *)frame->tf_sepc); 376 userret(td, frame); 377 break; 378 default: 379 dump_regs(frame); 380 panic("Unknown userland exception %x, badaddr %lx\n", 381 exception, frame->tf_sbadaddr); 382 } 383 } 384