sys/powerpc/powerpc/exec_machdep.c

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