1 /*- 2 * SPDX-License-Identifier: BSD-4-Clause AND BSD-2-Clause-FreeBSD 3 * 4 * Copyright (C) 1995, 1996 Wolfgang Solfrank. 5 * Copyright (C) 1995, 1996 TooLs GmbH. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed by TooLs GmbH. 19 * 4. The name of TooLs GmbH may not be used to endorse or promote products 20 * derived from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 25 * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 27 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 28 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 29 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 30 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 31 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 /*- 34 * Copyright (C) 2001 Benno Rice 35 * All rights reserved. 36 * 37 * Redistribution and use in source and binary forms, with or without 38 * modification, are permitted provided that the following conditions 39 * are met: 40 * 1. Redistributions of source code must retain the above copyright 41 * notice, this list of conditions and the following disclaimer. 42 * 2. Redistributions in binary form must reproduce the above copyright 43 * notice, this list of conditions and the following disclaimer in the 44 * documentation and/or other materials provided with the distribution. 45 * 46 * THIS SOFTWARE IS PROVIDED BY Benno Rice ``AS IS'' AND ANY EXPRESS OR 47 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 48 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 49 * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 50 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 51 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 52 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 53 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 54 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 55 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 56 * $NetBSD: machdep.c,v 1.74.2.1 2000/11/01 16:13:48 tv Exp $ 57 */ 58 59 #include <sys/cdefs.h> 60 __FBSDID("$FreeBSD$"); 61 62 #include "opt_fpu_emu.h" 63 64 #include <sys/param.h> 65 #include <sys/proc.h> 66 #include <sys/systm.h> 67 #include <sys/bio.h> 68 #include <sys/buf.h> 69 #include <sys/bus.h> 70 #include <sys/cons.h> 71 #include <sys/cpu.h> 72 #include <sys/exec.h> 73 #include <sys/imgact.h> 74 #include <sys/kernel.h> 75 #include <sys/ktr.h> 76 #include <sys/lock.h> 77 #include <sys/malloc.h> 78 #include <sys/mutex.h> 79 #include <sys/reg.h> 80 #include <sys/signalvar.h> 81 #include <sys/syscallsubr.h> 82 #include <sys/syscall.h> 83 #include <sys/sysent.h> 84 #include <sys/sysproto.h> 85 #include <sys/ucontext.h> 86 #include <sys/uio.h> 87 88 #include <machine/altivec.h> 89 #include <machine/cpu.h> 90 #include <machine/elf.h> 91 #include <machine/fpu.h> 92 #include <machine/pcb.h> 93 #include <machine/sigframe.h> 94 #include <machine/trap.h> 95 #include <machine/vmparam.h> 96 97 #include <vm/vm.h> 98 #include <vm/vm_param.h> 99 #include <vm/pmap.h> 100 #include <vm/vm_map.h> 101 102 #ifdef FPU_EMU 103 #include <powerpc/fpu/fpu_extern.h> 104 #endif 105 106 #ifdef COMPAT_FREEBSD32 107 #include <compat/freebsd32/freebsd32_signal.h> 108 #include <compat/freebsd32/freebsd32_util.h> 109 #include <compat/freebsd32/freebsd32_proto.h> 110 111 typedef struct __ucontext32 { 112 sigset_t uc_sigmask; 113 mcontext32_t uc_mcontext; 114 uint32_t uc_link; 115 struct sigaltstack32 uc_stack; 116 uint32_t uc_flags; 117 uint32_t __spare__[4]; 118 } ucontext32_t; 119 120 struct sigframe32 { 121 ucontext32_t sf_uc; 122 struct siginfo32 sf_si; 123 }; 124 125 static int grab_mcontext32(struct thread *td, mcontext32_t *, int flags); 126 #endif 127 128 static int grab_mcontext(struct thread *, mcontext_t *, int); 129 130 static void cleanup_power_extras(struct thread *); 131 132 #ifdef __powerpc64__ 133 extern struct sysentvec elf64_freebsd_sysvec_v2; 134 #endif 135 136 #ifdef __powerpc64__ 137 _Static_assert(sizeof(mcontext_t) == 1392, "mcontext_t size incorrect"); 138 _Static_assert(sizeof(ucontext_t) == 1472, "ucontext_t size incorrect"); 139 _Static_assert(sizeof(siginfo_t) == 80, "siginfo_t size incorrect"); 140 #ifdef COMPAT_FREEBSD32 141 _Static_assert(sizeof(mcontext32_t) == 1224, "mcontext32_t size incorrect"); 142 _Static_assert(sizeof(ucontext32_t) == 1280, "ucontext32_t size incorrect"); 143 _Static_assert(sizeof(struct siginfo32) == 64, "struct siginfo32 size incorrect"); 144 #endif /* COMPAT_FREEBSD32 */ 145 #else /* powerpc */ 146 _Static_assert(sizeof(mcontext_t) == 1224, "mcontext_t size incorrect"); 147 _Static_assert(sizeof(ucontext_t) == 1280, "ucontext_t size incorrect"); 148 _Static_assert(sizeof(siginfo_t) == 64, "siginfo_t size incorrect"); 149 #endif 150 151 void 152 sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask) 153 { 154 struct trapframe *tf; 155 struct sigacts *psp; 156 struct sigframe sf; 157 struct thread *td; 158 struct proc *p; 159 #ifdef COMPAT_FREEBSD32 160 struct siginfo32 siginfo32; 161 struct sigframe32 sf32; 162 #endif 163 size_t sfpsize; 164 caddr_t sfp, usfp; 165 register_t sp; 166 int oonstack, rndfsize; 167 int sig; 168 int code; 169 170 td = curthread; 171 p = td->td_proc; 172 PROC_LOCK_ASSERT(p, MA_OWNED); 173 174 psp = p->p_sigacts; 175 mtx_assert(&psp->ps_mtx, MA_OWNED); 176 tf = td->td_frame; 177 178 /* 179 * Fill siginfo structure. 180 */ 181 ksi->ksi_info.si_signo = ksi->ksi_signo; 182 ksi->ksi_info.si_addr = 183 (void *)((tf->exc == EXC_DSI || tf->exc == EXC_DSE) ? 184 tf->dar : tf->srr0); 185 186 #ifdef COMPAT_FREEBSD32 187 if (SV_PROC_FLAG(p, SV_ILP32)) { 188 siginfo_to_siginfo32(&ksi->ksi_info, &siginfo32); 189 sig = siginfo32.si_signo; 190 code = siginfo32.si_code; 191 sfp = (caddr_t)&sf32; 192 sfpsize = sizeof(sf32); 193 rndfsize = roundup(sizeof(sf32), 16); 194 sp = (uint32_t)tf->fixreg[1]; 195 oonstack = sigonstack(sp); 196 197 /* 198 * Save user context 199 */ 200 201 memset(&sf32, 0, sizeof(sf32)); 202 grab_mcontext32(td, &sf32.sf_uc.uc_mcontext, 0); 203 204 sf32.sf_uc.uc_sigmask = *mask; 205 sf32.sf_uc.uc_stack.ss_sp = (uintptr_t)td->td_sigstk.ss_sp; 206 sf32.sf_uc.uc_stack.ss_size = (uint32_t)td->td_sigstk.ss_size; 207 sf32.sf_uc.uc_stack.ss_flags = (td->td_pflags & TDP_ALTSTACK) 208 ? ((oonstack) ? SS_ONSTACK : 0) : SS_DISABLE; 209 210 sf32.sf_uc.uc_mcontext.mc_onstack = (oonstack) ? 1 : 0; 211 } else { 212 #endif 213 sig = ksi->ksi_signo; 214 code = ksi->ksi_code; 215 sfp = (caddr_t)&sf; 216 sfpsize = sizeof(sf); 217 #ifdef __powerpc64__ 218 /* 219 * 64-bit PPC defines a 288 byte scratch region 220 * below the stack. 221 */ 222 rndfsize = 288 + roundup(sizeof(sf), 48); 223 #else 224 rndfsize = roundup(sizeof(sf), 16); 225 #endif 226 sp = tf->fixreg[1]; 227 oonstack = sigonstack(sp); 228 229 /* 230 * Save user context 231 */ 232 233 memset(&sf, 0, sizeof(sf)); 234 grab_mcontext(td, &sf.sf_uc.uc_mcontext, 0); 235 236 sf.sf_uc.uc_sigmask = *mask; 237 sf.sf_uc.uc_stack = td->td_sigstk; 238 sf.sf_uc.uc_stack.ss_flags = (td->td_pflags & TDP_ALTSTACK) 239 ? ((oonstack) ? SS_ONSTACK : 0) : SS_DISABLE; 240 241 sf.sf_uc.uc_mcontext.mc_onstack = (oonstack) ? 1 : 0; 242 #ifdef COMPAT_FREEBSD32 243 } 244 #endif 245 246 CTR4(KTR_SIG, "sendsig: td=%p (%s) catcher=%p sig=%d", td, p->p_comm, 247 catcher, sig); 248 249 /* 250 * Allocate and validate space for the signal handler context. 251 */ 252 if ((td->td_pflags & TDP_ALTSTACK) != 0 && !oonstack && 253 SIGISMEMBER(psp->ps_sigonstack, sig)) { 254 usfp = (void *)(((uintptr_t)td->td_sigstk.ss_sp + 255 td->td_sigstk.ss_size - rndfsize) & ~0xFul); 256 } else { 257 usfp = (void *)((sp - rndfsize) & ~0xFul); 258 } 259 260 /* 261 * Set Floating Point facility to "Ignore Exceptions Mode" so signal 262 * handler can run. 263 */ 264 if (td->td_pcb->pcb_flags & PCB_FPU) 265 tf->srr1 = tf->srr1 & ~(PSL_FE0 | PSL_FE1); 266 267 /* 268 * Set up the registers to return to sigcode. 269 * 270 * r1/sp - sigframe ptr 271 * lr - sig function, dispatched to by blrl in trampoline 272 * r3 - sig number 273 * r4 - SIGINFO ? &siginfo : exception code 274 * r5 - user context 275 * srr0 - trampoline function addr 276 */ 277 tf->lr = (register_t)catcher; 278 tf->fixreg[1] = (register_t)usfp; 279 tf->fixreg[FIRSTARG] = sig; 280 #ifdef COMPAT_FREEBSD32 281 tf->fixreg[FIRSTARG+2] = (register_t)usfp + 282 ((SV_PROC_FLAG(p, SV_ILP32)) ? 283 offsetof(struct sigframe32, sf_uc) : 284 offsetof(struct sigframe, sf_uc)); 285 #else 286 tf->fixreg[FIRSTARG+2] = (register_t)usfp + 287 offsetof(struct sigframe, sf_uc); 288 #endif 289 if (SIGISMEMBER(psp->ps_siginfo, sig)) { 290 /* 291 * Signal handler installed with SA_SIGINFO. 292 */ 293 #ifdef COMPAT_FREEBSD32 294 if (SV_PROC_FLAG(p, SV_ILP32)) { 295 sf32.sf_si = siginfo32; 296 tf->fixreg[FIRSTARG+1] = (register_t)usfp + 297 offsetof(struct sigframe32, sf_si); 298 sf32.sf_si = siginfo32; 299 } else { 300 #endif 301 tf->fixreg[FIRSTARG+1] = (register_t)usfp + 302 offsetof(struct sigframe, sf_si); 303 sf.sf_si = ksi->ksi_info; 304 #ifdef COMPAT_FREEBSD32 305 } 306 #endif 307 } else { 308 /* Old FreeBSD-style arguments. */ 309 tf->fixreg[FIRSTARG+1] = code; 310 tf->fixreg[FIRSTARG+3] = (tf->exc == EXC_DSI) ? 311 tf->dar : tf->srr0; 312 } 313 mtx_unlock(&psp->ps_mtx); 314 PROC_UNLOCK(p); 315 316 tf->srr0 = (register_t)PROC_SIGCODE(p); 317 318 /* 319 * copy the frame out to userland. 320 */ 321 if (copyout(sfp, usfp, sfpsize) != 0) { 322 /* 323 * Process has trashed its stack. Kill it. 324 */ 325 CTR2(KTR_SIG, "sendsig: sigexit td=%p sfp=%p", td, sfp); 326 PROC_LOCK(p); 327 sigexit(td, SIGILL); 328 } 329 330 CTR3(KTR_SIG, "sendsig: return td=%p pc=%#x sp=%#x", td, 331 tf->srr0, tf->fixreg[1]); 332 333 PROC_LOCK(p); 334 mtx_lock(&psp->ps_mtx); 335 } 336 337 int 338 sys_sigreturn(struct thread *td, struct sigreturn_args *uap) 339 { 340 ucontext_t uc; 341 int error; 342 343 CTR2(KTR_SIG, "sigreturn: td=%p ucp=%p", td, uap->sigcntxp); 344 345 if (copyin(uap->sigcntxp, &uc, sizeof(uc)) != 0) { 346 CTR1(KTR_SIG, "sigreturn: efault td=%p", td); 347 return (EFAULT); 348 } 349 350 error = set_mcontext(td, &uc.uc_mcontext); 351 if (error != 0) 352 return (error); 353 354 /* 355 * Save FPU state if needed. User may have changed it on 356 * signal handler 357 */ 358 if (uc.uc_mcontext.mc_srr1 & PSL_FP) 359 save_fpu(td); 360 361 kern_sigprocmask(td, SIG_SETMASK, &uc.uc_sigmask, NULL, 0); 362 363 CTR3(KTR_SIG, "sigreturn: return td=%p pc=%#x sp=%#x", 364 td, uc.uc_mcontext.mc_srr0, uc.uc_mcontext.mc_gpr[1]); 365 366 return (EJUSTRETURN); 367 } 368 369 #ifdef COMPAT_FREEBSD4 370 int 371 freebsd4_sigreturn(struct thread *td, struct freebsd4_sigreturn_args *uap) 372 { 373 374 return sys_sigreturn(td, (struct sigreturn_args *)uap); 375 } 376 #endif 377 378 /* 379 * Construct a PCB from a trapframe. This is called from kdb_trap() where 380 * we want to start a backtrace from the function that caused us to enter 381 * the debugger. We have the context in the trapframe, but base the trace 382 * on the PCB. The PCB doesn't have to be perfect, as long as it contains 383 * enough for a backtrace. 384 */ 385 void 386 makectx(struct trapframe *tf, struct pcb *pcb) 387 { 388 389 pcb->pcb_lr = tf->srr0; 390 pcb->pcb_sp = tf->fixreg[1]; 391 } 392 393 /* 394 * get_mcontext/sendsig helper routine that doesn't touch the 395 * proc lock 396 */ 397 static int 398 grab_mcontext(struct thread *td, mcontext_t *mcp, int flags) 399 { 400 struct pcb *pcb; 401 int i; 402 403 pcb = td->td_pcb; 404 405 memset(mcp, 0, sizeof(mcontext_t)); 406 407 mcp->mc_vers = _MC_VERSION; 408 mcp->mc_flags = 0; 409 memcpy(&mcp->mc_frame, td->td_frame, sizeof(struct trapframe)); 410 if (flags & GET_MC_CLEAR_RET) { 411 mcp->mc_gpr[3] = 0; 412 mcp->mc_gpr[4] = 0; 413 } 414 415 /* 416 * This assumes that floating-point context is *not* lazy, 417 * so if the thread has used FP there would have been a 418 * FP-unavailable exception that would have set things up 419 * correctly. 420 */ 421 if (pcb->pcb_flags & PCB_FPREGS) { 422 if (pcb->pcb_flags & PCB_FPU) { 423 KASSERT(td == curthread, 424 ("get_mcontext: fp save not curthread")); 425 critical_enter(); 426 save_fpu(td); 427 critical_exit(); 428 } 429 mcp->mc_flags |= _MC_FP_VALID; 430 memcpy(&mcp->mc_fpscr, &pcb->pcb_fpu.fpscr, sizeof(double)); 431 for (i = 0; i < 32; i++) 432 memcpy(&mcp->mc_fpreg[i], &pcb->pcb_fpu.fpr[i].fpr, 433 sizeof(double)); 434 } 435 436 if (pcb->pcb_flags & PCB_VSX) { 437 for (i = 0; i < 32; i++) 438 memcpy(&mcp->mc_vsxfpreg[i], 439 &pcb->pcb_fpu.fpr[i].vsr[2], sizeof(double)); 440 } 441 442 /* 443 * Repeat for Altivec context 444 */ 445 446 if (pcb->pcb_flags & PCB_VEC) { 447 KASSERT(td == curthread, 448 ("get_mcontext: fp save not curthread")); 449 critical_enter(); 450 save_vec(td); 451 critical_exit(); 452 mcp->mc_flags |= _MC_AV_VALID; 453 mcp->mc_vscr = pcb->pcb_vec.vscr; 454 mcp->mc_vrsave = pcb->pcb_vec.vrsave; 455 memcpy(mcp->mc_avec, pcb->pcb_vec.vr, sizeof(mcp->mc_avec)); 456 } 457 458 mcp->mc_len = sizeof(*mcp); 459 460 return (0); 461 } 462 463 int 464 get_mcontext(struct thread *td, mcontext_t *mcp, int flags) 465 { 466 int error; 467 468 error = grab_mcontext(td, mcp, flags); 469 if (error == 0) { 470 PROC_LOCK(curthread->td_proc); 471 mcp->mc_onstack = sigonstack(td->td_frame->fixreg[1]); 472 PROC_UNLOCK(curthread->td_proc); 473 } 474 475 return (error); 476 } 477 478 int 479 set_mcontext(struct thread *td, mcontext_t *mcp) 480 { 481 struct pcb *pcb; 482 struct trapframe *tf; 483 register_t tls; 484 int i; 485 486 pcb = td->td_pcb; 487 tf = td->td_frame; 488 489 if (mcp->mc_vers != _MC_VERSION || mcp->mc_len != sizeof(*mcp)) 490 return (EINVAL); 491 492 /* 493 * Don't let the user change privileged MSR bits. 494 * 495 * psl_userstatic is used here to mask off any bits that can 496 * legitimately vary between user contexts (Floating point 497 * exception control and any facilities that we are using the 498 * "enable on first use" pattern with.) 499 * 500 * All other bits are required to match psl_userset(32). 501 * 502 * Remember to update the platform cpu_init code when implementing 503 * support for a new conditional facility! 504 */ 505 if ((mcp->mc_srr1 & psl_userstatic) != (tf->srr1 & psl_userstatic)) { 506 return (EINVAL); 507 } 508 509 /* Copy trapframe, preserving TLS pointer across context change */ 510 if (SV_PROC_FLAG(td->td_proc, SV_LP64)) 511 tls = tf->fixreg[13]; 512 else 513 tls = tf->fixreg[2]; 514 memcpy(tf, mcp->mc_frame, sizeof(mcp->mc_frame)); 515 if (SV_PROC_FLAG(td->td_proc, SV_LP64)) 516 tf->fixreg[13] = tls; 517 else 518 tf->fixreg[2] = tls; 519 520 /* 521 * Force the FPU back off to ensure the new context will not bypass 522 * the enable_fpu() setup code accidentally. 523 * 524 * This prevents an issue where a process that uses floating point 525 * inside a signal handler could end up in a state where the MSR 526 * did not match pcb_flags. 527 * 528 * Additionally, ensure VSX is disabled as well, as it is illegal 529 * to leave it turned on when FP or VEC are off. 530 */ 531 tf->srr1 &= ~(PSL_FP | PSL_VSX); 532 pcb->pcb_flags &= ~(PCB_FPU | PCB_VSX); 533 534 if (mcp->mc_flags & _MC_FP_VALID) { 535 /* enable_fpu() will happen lazily on a fault */ 536 pcb->pcb_flags |= PCB_FPREGS; 537 memcpy(&pcb->pcb_fpu.fpscr, &mcp->mc_fpscr, sizeof(double)); 538 bzero(pcb->pcb_fpu.fpr, sizeof(pcb->pcb_fpu.fpr)); 539 for (i = 0; i < 32; i++) { 540 memcpy(&pcb->pcb_fpu.fpr[i].fpr, &mcp->mc_fpreg[i], 541 sizeof(double)); 542 memcpy(&pcb->pcb_fpu.fpr[i].vsr[2], 543 &mcp->mc_vsxfpreg[i], sizeof(double)); 544 } 545 } 546 547 if (mcp->mc_flags & _MC_AV_VALID) { 548 if ((pcb->pcb_flags & PCB_VEC) != PCB_VEC) { 549 critical_enter(); 550 enable_vec(td); 551 critical_exit(); 552 } 553 pcb->pcb_vec.vscr = mcp->mc_vscr; 554 pcb->pcb_vec.vrsave = mcp->mc_vrsave; 555 memcpy(pcb->pcb_vec.vr, mcp->mc_avec, sizeof(mcp->mc_avec)); 556 } else { 557 tf->srr1 &= ~PSL_VEC; 558 pcb->pcb_flags &= ~PCB_VEC; 559 } 560 561 return (0); 562 } 563 564 /* 565 * Clean up extra POWER state. Some per-process registers and states are not 566 * managed by the MSR, so must be cleaned up explicitly on thread exit. 567 * 568 * Currently this includes: 569 * DSCR -- Data stream control register (PowerISA 2.06+) 570 * FSCR -- Facility Status and Control Register (PowerISA 2.07+) 571 */ 572 static void 573 cleanup_power_extras(struct thread *td) 574 { 575 uint32_t pcb_flags; 576 577 if (td != curthread) 578 return; 579 580 pcb_flags = td->td_pcb->pcb_flags; 581 /* Clean up registers not managed by MSR. */ 582 if (pcb_flags & PCB_CFSCR) 583 mtspr(SPR_FSCR, 0); 584 if (pcb_flags & PCB_CDSCR) 585 mtspr(SPR_DSCRP, 0); 586 587 if (pcb_flags & PCB_FPU) 588 cleanup_fpscr(); 589 } 590 591 /* 592 * Ensure the PCB has been updated in preparation for copying a thread. 593 * 594 * This is needed because normally this only happens during switching tasks, 595 * but when we are cloning a thread, we need the updated state before doing 596 * the actual copy, so the new thread inherits the current state instead of 597 * the state at the last task switch. 598 * 599 * Keep this in sync with the assembly code in cpu_switch()! 600 */ 601 void 602 cpu_save_thread_regs(struct thread *td) 603 { 604 uint32_t pcb_flags; 605 struct pcb *pcb; 606 607 KASSERT(td == curthread, 608 ("cpu_save_thread_regs: td is not curthread")); 609 610 pcb = td->td_pcb; 611 612 pcb_flags = pcb->pcb_flags; 613 614 #if defined(__powerpc64__) 615 /* Are *any* FSCR flags in use? */ 616 if (pcb_flags & PCB_CFSCR) { 617 pcb->pcb_fscr = mfspr(SPR_FSCR); 618 619 if (pcb->pcb_fscr & FSCR_EBB) { 620 pcb->pcb_ebb.ebbhr = mfspr(SPR_EBBHR); 621 pcb->pcb_ebb.ebbrr = mfspr(SPR_EBBRR); 622 pcb->pcb_ebb.bescr = mfspr(SPR_BESCR); 623 } 624 if (pcb->pcb_fscr & FSCR_LM) { 625 pcb->pcb_lm.lmrr = mfspr(SPR_LMRR); 626 pcb->pcb_lm.lmser = mfspr(SPR_LMSER); 627 } 628 if (pcb->pcb_fscr & FSCR_TAR) 629 pcb->pcb_tar = mfspr(SPR_TAR); 630 } 631 632 /* 633 * This is outside of the PCB_CFSCR check because it can be set 634 * independently when running on POWER7/POWER8. 635 */ 636 if (pcb_flags & PCB_CDSCR) 637 pcb->pcb_dscr = mfspr(SPR_DSCRP); 638 #endif 639 640 #if defined(__SPE__) 641 /* 642 * On E500v2, single-precision scalar instructions and access to 643 * SPEFSCR may be used without PSL_VEC turned on, as long as they 644 * limit themselves to the low word of the registers. 645 * 646 * As such, we need to unconditionally save SPEFSCR, even though 647 * it is also updated in save_vec_nodrop(). 648 */ 649 pcb->pcb_vec.vscr = mfspr(SPR_SPEFSCR); 650 #endif 651 652 if (pcb_flags & PCB_FPU) 653 save_fpu_nodrop(td); 654 655 if (pcb_flags & PCB_VEC) 656 save_vec_nodrop(td); 657 } 658 659 /* 660 * Set set up registers on exec. 661 */ 662 void 663 exec_setregs(struct thread *td, struct image_params *imgp, uintptr_t stack) 664 { 665 struct trapframe *tf; 666 register_t argc; 667 668 tf = trapframe(td); 669 bzero(tf, sizeof *tf); 670 #ifdef __powerpc64__ 671 tf->fixreg[1] = -roundup(-stack + 48, 16); 672 #else 673 tf->fixreg[1] = -roundup(-stack + 8, 16); 674 #endif 675 676 /* 677 * Set up arguments for _start(): 678 * _start(argc, argv, envp, obj, cleanup, ps_strings); 679 * 680 * Notes: 681 * - obj and cleanup are the auxilliary and termination 682 * vectors. They are fixed up by ld.elf_so. 683 * - ps_strings is a NetBSD extention, and will be 684 * ignored by executables which are strictly 685 * compliant with the SVR4 ABI. 686 */ 687 688 /* Collect argc from the user stack */ 689 argc = fuword((void *)stack); 690 691 tf->fixreg[3] = argc; 692 tf->fixreg[4] = stack + sizeof(register_t); 693 tf->fixreg[5] = stack + (2 + argc)*sizeof(register_t); 694 tf->fixreg[6] = 0; /* auxiliary vector */ 695 tf->fixreg[7] = 0; /* termination vector */ 696 tf->fixreg[8] = (register_t)imgp->ps_strings; /* NetBSD extension */ 697 698 tf->srr0 = imgp->entry_addr; 699 #ifdef __powerpc64__ 700 tf->fixreg[12] = imgp->entry_addr; 701 #endif 702 tf->srr1 = psl_userset | PSL_FE_DFLT; 703 cleanup_power_extras(td); 704 td->td_pcb->pcb_flags = 0; 705 } 706 707 #ifdef COMPAT_FREEBSD32 708 void 709 ppc32_setregs(struct thread *td, struct image_params *imgp, uintptr_t stack) 710 { 711 struct trapframe *tf; 712 uint32_t argc; 713 714 tf = trapframe(td); 715 bzero(tf, sizeof *tf); 716 tf->fixreg[1] = -roundup(-stack + 8, 16); 717 718 argc = fuword32((void *)stack); 719 720 tf->fixreg[3] = argc; 721 tf->fixreg[4] = stack + sizeof(uint32_t); 722 tf->fixreg[5] = stack + (2 + argc)*sizeof(uint32_t); 723 tf->fixreg[6] = 0; /* auxiliary vector */ 724 tf->fixreg[7] = 0; /* termination vector */ 725 tf->fixreg[8] = (register_t)imgp->ps_strings; /* NetBSD extension */ 726 727 tf->srr0 = imgp->entry_addr; 728 tf->srr1 = psl_userset32 | PSL_FE_DFLT; 729 cleanup_power_extras(td); 730 td->td_pcb->pcb_flags = 0; 731 } 732 #endif 733 734 int 735 fill_regs(struct thread *td, struct reg *regs) 736 { 737 struct trapframe *tf; 738 739 tf = td->td_frame; 740 memcpy(regs, tf, sizeof(struct reg)); 741 742 return (0); 743 } 744 745 int 746 fill_dbregs(struct thread *td, struct dbreg *dbregs) 747 { 748 /* No debug registers on PowerPC */ 749 return (ENOSYS); 750 } 751 752 int 753 fill_fpregs(struct thread *td, struct fpreg *fpregs) 754 { 755 struct pcb *pcb; 756 int i; 757 758 pcb = td->td_pcb; 759 760 if ((pcb->pcb_flags & PCB_FPREGS) == 0) 761 memset(fpregs, 0, sizeof(struct fpreg)); 762 else { 763 memcpy(&fpregs->fpscr, &pcb->pcb_fpu.fpscr, sizeof(double)); 764 for (i = 0; i < 32; i++) 765 memcpy(&fpregs->fpreg[i], &pcb->pcb_fpu.fpr[i].fpr, 766 sizeof(double)); 767 } 768 769 return (0); 770 } 771 772 int 773 set_regs(struct thread *td, struct reg *regs) 774 { 775 struct trapframe *tf; 776 777 tf = td->td_frame; 778 memcpy(tf, regs, sizeof(struct reg)); 779 780 return (0); 781 } 782 783 int 784 set_dbregs(struct thread *td, struct dbreg *dbregs) 785 { 786 /* No debug registers on PowerPC */ 787 return (ENOSYS); 788 } 789 790 int 791 set_fpregs(struct thread *td, struct fpreg *fpregs) 792 { 793 struct pcb *pcb; 794 int i; 795 796 pcb = td->td_pcb; 797 pcb->pcb_flags |= PCB_FPREGS; 798 memcpy(&pcb->pcb_fpu.fpscr, &fpregs->fpscr, sizeof(double)); 799 for (i = 0; i < 32; i++) { 800 memcpy(&pcb->pcb_fpu.fpr[i].fpr, &fpregs->fpreg[i], 801 sizeof(double)); 802 } 803 804 return (0); 805 } 806 807 #ifdef COMPAT_FREEBSD32 808 int 809 set_regs32(struct thread *td, struct reg32 *regs) 810 { 811 struct trapframe *tf; 812 int i; 813 814 tf = td->td_frame; 815 for (i = 0; i < 32; i++) 816 tf->fixreg[i] = regs->fixreg[i]; 817 tf->lr = regs->lr; 818 tf->cr = regs->cr; 819 tf->xer = regs->xer; 820 tf->ctr = regs->ctr; 821 tf->srr0 = regs->pc; 822 823 return (0); 824 } 825 826 int 827 fill_regs32(struct thread *td, struct reg32 *regs) 828 { 829 struct trapframe *tf; 830 int i; 831 832 tf = td->td_frame; 833 for (i = 0; i < 32; i++) 834 regs->fixreg[i] = tf->fixreg[i]; 835 regs->lr = tf->lr; 836 regs->cr = tf->cr; 837 regs->xer = tf->xer; 838 regs->ctr = tf->ctr; 839 regs->pc = tf->srr0; 840 841 return (0); 842 } 843 844 static int 845 grab_mcontext32(struct thread *td, mcontext32_t *mcp, int flags) 846 { 847 mcontext_t mcp64; 848 int i, error; 849 850 error = grab_mcontext(td, &mcp64, flags); 851 if (error != 0) 852 return (error); 853 854 mcp->mc_vers = mcp64.mc_vers; 855 mcp->mc_flags = mcp64.mc_flags; 856 mcp->mc_onstack = mcp64.mc_onstack; 857 mcp->mc_len = mcp64.mc_len; 858 memcpy(mcp->mc_avec,mcp64.mc_avec,sizeof(mcp64.mc_avec)); 859 memcpy(mcp->mc_av,mcp64.mc_av,sizeof(mcp64.mc_av)); 860 for (i = 0; i < 42; i++) 861 mcp->mc_frame[i] = mcp64.mc_frame[i]; 862 memcpy(mcp->mc_fpreg,mcp64.mc_fpreg,sizeof(mcp64.mc_fpreg)); 863 memcpy(mcp->mc_vsxfpreg,mcp64.mc_vsxfpreg,sizeof(mcp64.mc_vsxfpreg)); 864 865 return (0); 866 } 867 868 static int 869 get_mcontext32(struct thread *td, mcontext32_t *mcp, int flags) 870 { 871 int error; 872 873 error = grab_mcontext32(td, mcp, flags); 874 if (error == 0) { 875 PROC_LOCK(curthread->td_proc); 876 mcp->mc_onstack = sigonstack(td->td_frame->fixreg[1]); 877 PROC_UNLOCK(curthread->td_proc); 878 } 879 880 return (error); 881 } 882 883 static int 884 set_mcontext32(struct thread *td, mcontext32_t *mcp) 885 { 886 mcontext_t mcp64; 887 int i, error; 888 889 mcp64.mc_vers = mcp->mc_vers; 890 mcp64.mc_flags = mcp->mc_flags; 891 mcp64.mc_onstack = mcp->mc_onstack; 892 mcp64.mc_len = mcp->mc_len; 893 memcpy(mcp64.mc_avec,mcp->mc_avec,sizeof(mcp64.mc_avec)); 894 memcpy(mcp64.mc_av,mcp->mc_av,sizeof(mcp64.mc_av)); 895 for (i = 0; i < 42; i++) 896 mcp64.mc_frame[i] = mcp->mc_frame[i]; 897 mcp64.mc_srr1 |= (td->td_frame->srr1 & 0xFFFFFFFF00000000ULL); 898 memcpy(mcp64.mc_fpreg,mcp->mc_fpreg,sizeof(mcp64.mc_fpreg)); 899 memcpy(mcp64.mc_vsxfpreg,mcp->mc_vsxfpreg,sizeof(mcp64.mc_vsxfpreg)); 900 901 error = set_mcontext(td, &mcp64); 902 903 return (error); 904 } 905 #endif 906 907 #ifdef COMPAT_FREEBSD32 908 int 909 freebsd32_sigreturn(struct thread *td, struct freebsd32_sigreturn_args *uap) 910 { 911 ucontext32_t uc; 912 int error; 913 914 CTR2(KTR_SIG, "sigreturn: td=%p ucp=%p", td, uap->sigcntxp); 915 916 if (copyin(uap->sigcntxp, &uc, sizeof(uc)) != 0) { 917 CTR1(KTR_SIG, "sigreturn: efault td=%p", td); 918 return (EFAULT); 919 } 920 921 error = set_mcontext32(td, &uc.uc_mcontext); 922 if (error != 0) 923 return (error); 924 925 /* 926 * Save FPU state if needed. User may have changed it on 927 * signal handler 928 */ 929 if (uc.uc_mcontext.mc_srr1 & PSL_FP) 930 save_fpu(td); 931 932 kern_sigprocmask(td, SIG_SETMASK, &uc.uc_sigmask, NULL, 0); 933 934 CTR3(KTR_SIG, "sigreturn: return td=%p pc=%#x sp=%#x", 935 td, uc.uc_mcontext.mc_srr0, uc.uc_mcontext.mc_gpr[1]); 936 937 return (EJUSTRETURN); 938 } 939 940 /* 941 * The first two fields of a ucontext_t are the signal mask and the machine 942 * context. The next field is uc_link; we want to avoid destroying the link 943 * when copying out contexts. 944 */ 945 #define UC32_COPY_SIZE offsetof(ucontext32_t, uc_link) 946 947 int 948 freebsd32_getcontext(struct thread *td, struct freebsd32_getcontext_args *uap) 949 { 950 ucontext32_t uc; 951 int ret; 952 953 if (uap->ucp == NULL) 954 ret = EINVAL; 955 else { 956 bzero(&uc, sizeof(uc)); 957 get_mcontext32(td, &uc.uc_mcontext, GET_MC_CLEAR_RET); 958 PROC_LOCK(td->td_proc); 959 uc.uc_sigmask = td->td_sigmask; 960 PROC_UNLOCK(td->td_proc); 961 ret = copyout(&uc, uap->ucp, UC32_COPY_SIZE); 962 } 963 return (ret); 964 } 965 966 int 967 freebsd32_setcontext(struct thread *td, struct freebsd32_setcontext_args *uap) 968 { 969 ucontext32_t uc; 970 int ret; 971 972 if (uap->ucp == NULL) 973 ret = EINVAL; 974 else { 975 ret = copyin(uap->ucp, &uc, UC32_COPY_SIZE); 976 if (ret == 0) { 977 ret = set_mcontext32(td, &uc.uc_mcontext); 978 if (ret == 0) { 979 kern_sigprocmask(td, SIG_SETMASK, 980 &uc.uc_sigmask, NULL, 0); 981 } 982 } 983 } 984 return (ret == 0 ? EJUSTRETURN : ret); 985 } 986 987 int 988 freebsd32_swapcontext(struct thread *td, struct freebsd32_swapcontext_args *uap) 989 { 990 ucontext32_t uc; 991 int ret; 992 993 if (uap->oucp == NULL || uap->ucp == NULL) 994 ret = EINVAL; 995 else { 996 bzero(&uc, sizeof(uc)); 997 get_mcontext32(td, &uc.uc_mcontext, GET_MC_CLEAR_RET); 998 PROC_LOCK(td->td_proc); 999 uc.uc_sigmask = td->td_sigmask; 1000 PROC_UNLOCK(td->td_proc); 1001 ret = copyout(&uc, uap->oucp, UC32_COPY_SIZE); 1002 if (ret == 0) { 1003 ret = copyin(uap->ucp, &uc, UC32_COPY_SIZE); 1004 if (ret == 0) { 1005 ret = set_mcontext32(td, &uc.uc_mcontext); 1006 if (ret == 0) { 1007 kern_sigprocmask(td, SIG_SETMASK, 1008 &uc.uc_sigmask, NULL, 0); 1009 } 1010 } 1011 } 1012 } 1013 return (ret == 0 ? EJUSTRETURN : ret); 1014 } 1015 1016 #endif 1017 1018 void 1019 cpu_set_syscall_retval(struct thread *td, int error) 1020 { 1021 struct proc *p; 1022 struct trapframe *tf; 1023 int fixup; 1024 1025 if (error == EJUSTRETURN) 1026 return; 1027 1028 p = td->td_proc; 1029 tf = td->td_frame; 1030 1031 if (tf->fixreg[0] == SYS___syscall && 1032 (SV_PROC_FLAG(p, SV_ILP32))) { 1033 int code = tf->fixreg[FIRSTARG + 1]; 1034 fixup = ( 1035 #if defined(COMPAT_FREEBSD6) && defined(SYS_freebsd6_lseek) 1036 code != SYS_freebsd6_lseek && 1037 #endif 1038 code != SYS_lseek) ? 1 : 0; 1039 } else 1040 fixup = 0; 1041 1042 switch (error) { 1043 case 0: 1044 if (fixup) { 1045 /* 1046 * 64-bit return, 32-bit syscall. Fixup byte order 1047 */ 1048 tf->fixreg[FIRSTARG] = 0; 1049 tf->fixreg[FIRSTARG + 1] = td->td_retval[0]; 1050 } else { 1051 tf->fixreg[FIRSTARG] = td->td_retval[0]; 1052 tf->fixreg[FIRSTARG + 1] = td->td_retval[1]; 1053 } 1054 tf->cr &= ~0x10000000; /* Unset summary overflow */ 1055 break; 1056 case ERESTART: 1057 /* 1058 * Set user's pc back to redo the system call. 1059 */ 1060 tf->srr0 -= 4; 1061 break; 1062 default: 1063 tf->fixreg[FIRSTARG] = error; 1064 tf->cr |= 0x10000000; /* Set summary overflow */ 1065 break; 1066 } 1067 } 1068 1069 /* 1070 * Threading functions 1071 */ 1072 void 1073 cpu_thread_exit(struct thread *td) 1074 { 1075 cleanup_power_extras(td); 1076 } 1077 1078 void 1079 cpu_thread_clean(struct thread *td) 1080 { 1081 } 1082 1083 void 1084 cpu_thread_alloc(struct thread *td) 1085 { 1086 struct pcb *pcb; 1087 1088 pcb = (struct pcb *)((td->td_kstack + td->td_kstack_pages * PAGE_SIZE - 1089 sizeof(struct pcb)) & ~0x2fUL); 1090 td->td_pcb = pcb; 1091 td->td_frame = (struct trapframe *)pcb - 1; 1092 } 1093 1094 void 1095 cpu_thread_free(struct thread *td) 1096 { 1097 } 1098 1099 int 1100 cpu_set_user_tls(struct thread *td, void *tls_base) 1101 { 1102 1103 if (SV_PROC_FLAG(td->td_proc, SV_LP64)) 1104 td->td_frame->fixreg[13] = (register_t)tls_base + 0x7010; 1105 else 1106 td->td_frame->fixreg[2] = (register_t)tls_base + 0x7008; 1107 return (0); 1108 } 1109 1110 void 1111 cpu_copy_thread(struct thread *td, struct thread *td0) 1112 { 1113 struct pcb *pcb2; 1114 struct trapframe *tf; 1115 struct callframe *cf; 1116 1117 /* Ensure td0 pcb is up to date. */ 1118 if (td0 == curthread) 1119 cpu_save_thread_regs(td0); 1120 1121 pcb2 = td->td_pcb; 1122 1123 /* Copy the upcall pcb */ 1124 bcopy(td0->td_pcb, pcb2, sizeof(*pcb2)); 1125 1126 /* Create a stack for the new thread */ 1127 tf = td->td_frame; 1128 bcopy(td0->td_frame, tf, sizeof(struct trapframe)); 1129 tf->fixreg[FIRSTARG] = 0; 1130 tf->fixreg[FIRSTARG + 1] = 0; 1131 tf->cr &= ~0x10000000; 1132 1133 /* Set registers for trampoline to user mode. */ 1134 cf = (struct callframe *)tf - 1; 1135 memset(cf, 0, sizeof(struct callframe)); 1136 cf->cf_func = (register_t)fork_return; 1137 cf->cf_arg0 = (register_t)td; 1138 cf->cf_arg1 = (register_t)tf; 1139 1140 pcb2->pcb_sp = (register_t)cf; 1141 #if defined(__powerpc64__) && (!defined(_CALL_ELF) || _CALL_ELF == 1) 1142 pcb2->pcb_lr = ((register_t *)fork_trampoline)[0]; 1143 pcb2->pcb_toc = ((register_t *)fork_trampoline)[1]; 1144 #else 1145 pcb2->pcb_lr = (register_t)fork_trampoline; 1146 pcb2->pcb_context[0] = pcb2->pcb_lr; 1147 #endif 1148 pcb2->pcb_cpu.aim.usr_vsid = 0; 1149 #ifdef __SPE__ 1150 pcb2->pcb_vec.vscr = SPEFSCR_DFLT; 1151 #endif 1152 1153 /* Setup to release spin count in fork_exit(). */ 1154 td->td_md.md_spinlock_count = 1; 1155 td->td_md.md_saved_msr = psl_kernset; 1156 } 1157 1158 void 1159 cpu_set_upcall(struct thread *td, void (*entry)(void *), void *arg, 1160 stack_t *stack) 1161 { 1162 struct trapframe *tf; 1163 uintptr_t sp; 1164 1165 tf = td->td_frame; 1166 /* align stack and alloc space for frame ptr and saved LR */ 1167 #ifdef __powerpc64__ 1168 sp = ((uintptr_t)stack->ss_sp + stack->ss_size - 48) & 1169 ~0x1f; 1170 #else 1171 sp = ((uintptr_t)stack->ss_sp + stack->ss_size - 8) & 1172 ~0x1f; 1173 #endif 1174 bzero(tf, sizeof(struct trapframe)); 1175 1176 tf->fixreg[1] = (register_t)sp; 1177 tf->fixreg[3] = (register_t)arg; 1178 if (SV_PROC_FLAG(td->td_proc, SV_ILP32)) { 1179 tf->srr0 = (register_t)entry; 1180 #ifdef __powerpc64__ 1181 tf->srr1 = psl_userset32 | PSL_FE_DFLT; 1182 #else 1183 tf->srr1 = psl_userset | PSL_FE_DFLT; 1184 #endif 1185 } else { 1186 #ifdef __powerpc64__ 1187 if (td->td_proc->p_sysent == &elf64_freebsd_sysvec_v2) { 1188 tf->srr0 = (register_t)entry; 1189 /* ELFv2 ABI requires that the global entry point be in r12. */ 1190 tf->fixreg[12] = (register_t)entry; 1191 } 1192 else { 1193 register_t entry_desc[3]; 1194 (void)copyin((void *)entry, entry_desc, sizeof(entry_desc)); 1195 tf->srr0 = entry_desc[0]; 1196 tf->fixreg[2] = entry_desc[1]; 1197 tf->fixreg[11] = entry_desc[2]; 1198 } 1199 tf->srr1 = psl_userset | PSL_FE_DFLT; 1200 #endif 1201 } 1202 1203 td->td_pcb->pcb_flags = 0; 1204 #ifdef __SPE__ 1205 td->td_pcb->pcb_vec.vscr = SPEFSCR_DFLT; 1206 #endif 1207 1208 td->td_retval[0] = (register_t)entry; 1209 td->td_retval[1] = 0; 1210 } 1211 1212 static int 1213 emulate_mfspr(int spr, int reg, struct trapframe *frame){ 1214 struct thread *td; 1215 1216 td = curthread; 1217 1218 if (spr == SPR_DSCR || spr == SPR_DSCRP) { 1219 if (!(cpu_features2 & PPC_FEATURE2_DSCR)) 1220 return (SIGILL); 1221 // If DSCR was never set, get the default DSCR 1222 if ((td->td_pcb->pcb_flags & PCB_CDSCR) == 0) 1223 td->td_pcb->pcb_dscr = mfspr(SPR_DSCRP); 1224 1225 frame->fixreg[reg] = td->td_pcb->pcb_dscr; 1226 frame->srr0 += 4; 1227 return (0); 1228 } else 1229 return (SIGILL); 1230 } 1231 1232 static int 1233 emulate_mtspr(int spr, int reg, struct trapframe *frame){ 1234 struct thread *td; 1235 1236 td = curthread; 1237 1238 if (spr == SPR_DSCR || spr == SPR_DSCRP) { 1239 if (!(cpu_features2 & PPC_FEATURE2_DSCR)) 1240 return (SIGILL); 1241 td->td_pcb->pcb_flags |= PCB_CDSCR; 1242 td->td_pcb->pcb_dscr = frame->fixreg[reg]; 1243 mtspr(SPR_DSCRP, frame->fixreg[reg]); 1244 frame->srr0 += 4; 1245 return (0); 1246 } else 1247 return (SIGILL); 1248 } 1249 1250 #define XFX 0xFC0007FF 1251 int 1252 ppc_instr_emulate(struct trapframe *frame, struct thread *td) 1253 { 1254 struct pcb *pcb; 1255 uint32_t instr; 1256 int reg, sig; 1257 int rs, spr; 1258 1259 instr = fuword32((void *)frame->srr0); 1260 sig = SIGILL; 1261 1262 if ((instr & 0xfc1fffff) == 0x7c1f42a6) { /* mfpvr */ 1263 reg = (instr & ~0xfc1fffff) >> 21; 1264 frame->fixreg[reg] = mfpvr(); 1265 frame->srr0 += 4; 1266 return (0); 1267 } else if ((instr & XFX) == 0x7c0002a6) { /* mfspr */ 1268 rs = (instr & 0x3e00000) >> 21; 1269 spr = (instr & 0x1ff800) >> 16; 1270 return emulate_mfspr(spr, rs, frame); 1271 } else if ((instr & XFX) == 0x7c0003a6) { /* mtspr */ 1272 rs = (instr & 0x3e00000) >> 21; 1273 spr = (instr & 0x1ff800) >> 16; 1274 return emulate_mtspr(spr, rs, frame); 1275 } else if ((instr & 0xfc000ffe) == 0x7c0004ac) { /* various sync */ 1276 powerpc_sync(); /* Do a heavy-weight sync */ 1277 frame->srr0 += 4; 1278 return (0); 1279 } 1280 1281 pcb = td->td_pcb; 1282 #ifdef FPU_EMU 1283 if (!(pcb->pcb_flags & PCB_FPREGS)) { 1284 bzero(&pcb->pcb_fpu, sizeof(pcb->pcb_fpu)); 1285 pcb->pcb_flags |= PCB_FPREGS; 1286 } else if (pcb->pcb_flags & PCB_FPU) 1287 save_fpu(td); 1288 sig = fpu_emulate(frame, &pcb->pcb_fpu); 1289 if ((sig == 0 || sig == SIGFPE) && pcb->pcb_flags & PCB_FPU) 1290 enable_fpu(td); 1291 #endif 1292 if (sig == SIGILL) { 1293 if (pcb->pcb_lastill != frame->srr0) { 1294 /* Allow a second chance, in case of cache sync issues. */ 1295 sig = 0; 1296 pmap_sync_icache(PCPU_GET(curpmap), frame->srr0, 4); 1297 pcb->pcb_lastill = frame->srr0; 1298 } 1299 } 1300 1301 return (sig); 1302 } 1303