1d85631c4SPeter Wemm /*- 251369649SPedro F. Giffuni * SPDX-License-Identifier: BSD-3-Clause 351369649SPedro F. Giffuni * 4d85631c4SPeter Wemm * Copyright (c) 2003 Peter Wemm 5d85631c4SPeter Wemm * Copyright (c) 1982, 1987, 1990 The Regents of the University of California. 6d85631c4SPeter Wemm * All rights reserved. 7d85631c4SPeter Wemm * 8d85631c4SPeter Wemm * This code is derived from software contributed to Berkeley by 9d85631c4SPeter Wemm * William Jolitz. 10d85631c4SPeter Wemm * 11d85631c4SPeter Wemm * Redistribution and use in source and binary forms, with or without 12d85631c4SPeter Wemm * modification, are permitted provided that the following conditions 13d85631c4SPeter Wemm * are met: 14d85631c4SPeter Wemm * 1. Redistributions of source code must retain the above copyright 15d85631c4SPeter Wemm * notice, this list of conditions and the following disclaimer. 16d85631c4SPeter Wemm * 2. Redistributions in binary form must reproduce the above copyright 17d85631c4SPeter Wemm * notice, this list of conditions and the following disclaimer in the 18d85631c4SPeter Wemm * documentation and/or other materials provided with the distribution. 19fbbd9655SWarner Losh * 3. Neither the name of the University nor the names of its contributors 20d85631c4SPeter Wemm * may be used to endorse or promote products derived from this software 21d85631c4SPeter Wemm * without specific prior written permission. 22d85631c4SPeter Wemm * 23d85631c4SPeter Wemm * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 24d85631c4SPeter Wemm * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25d85631c4SPeter Wemm * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26d85631c4SPeter Wemm * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 27d85631c4SPeter Wemm * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28d85631c4SPeter Wemm * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29d85631c4SPeter Wemm * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30d85631c4SPeter Wemm * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31d85631c4SPeter Wemm * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32d85631c4SPeter Wemm * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33d85631c4SPeter Wemm * SUCH DAMAGE. 34d85631c4SPeter Wemm */ 35d85631c4SPeter Wemm 3656ae44c5SDavid E. O'Brien #include <sys/cdefs.h> 3756ae44c5SDavid E. O'Brien __FBSDID("$FreeBSD$"); 3856ae44c5SDavid E. O'Brien 39d85631c4SPeter Wemm #include <sys/param.h> 40d85631c4SPeter Wemm #include <sys/exec.h> 41d85631c4SPeter Wemm #include <sys/fcntl.h> 42d85631c4SPeter Wemm #include <sys/imgact.h> 43d85631c4SPeter Wemm #include <sys/kernel.h> 44d85631c4SPeter Wemm #include <sys/lock.h> 45d85631c4SPeter Wemm #include <sys/malloc.h> 46d85631c4SPeter Wemm #include <sys/mutex.h> 47d85631c4SPeter Wemm #include <sys/mman.h> 48d85631c4SPeter Wemm #include <sys/namei.h> 49d85631c4SPeter Wemm #include <sys/proc.h> 50d85631c4SPeter Wemm #include <sys/procfs.h> 51d85631c4SPeter Wemm #include <sys/resourcevar.h> 52d85631c4SPeter Wemm #include <sys/systm.h> 53d85631c4SPeter Wemm #include <sys/signalvar.h> 54d85631c4SPeter Wemm #include <sys/stat.h> 55d85631c4SPeter Wemm #include <sys/sx.h> 56d85631c4SPeter Wemm #include <sys/syscall.h> 57fc0de8f0SJohn Baldwin #include <sys/syscallsubr.h> 58d85631c4SPeter Wemm #include <sys/sysctl.h> 59d85631c4SPeter Wemm #include <sys/sysent.h> 60d85631c4SPeter Wemm #include <sys/vnode.h> 61d85631c4SPeter Wemm 62d85631c4SPeter Wemm #include <vm/vm.h> 63d85631c4SPeter Wemm #include <vm/vm_kern.h> 64d85631c4SPeter Wemm #include <vm/vm_param.h> 65d85631c4SPeter Wemm #include <vm/pmap.h> 66d85631c4SPeter Wemm #include <vm/vm_map.h> 67d85631c4SPeter Wemm #include <vm/vm_object.h> 68d85631c4SPeter Wemm #include <vm/vm_extern.h> 69d85631c4SPeter Wemm 70c6511aeaSDavid Xu #include <compat/freebsd32/freebsd32_signal.h> 7146159d1fSPeter Wemm #include <compat/freebsd32/freebsd32_util.h> 7246159d1fSPeter Wemm #include <compat/freebsd32/freebsd32_proto.h> 738c6f8f3dSKonstantin Belousov #include <compat/freebsd32/freebsd32.h> 7446159d1fSPeter Wemm #include <compat/ia32/ia32_signal.h> 75d85631c4SPeter Wemm #include <machine/psl.h> 76d85631c4SPeter Wemm #include <machine/segments.h> 77d85631c4SPeter Wemm #include <machine/specialreg.h> 78d85631c4SPeter Wemm #include <machine/frame.h> 79d85631c4SPeter Wemm #include <machine/md_var.h> 80d85631c4SPeter Wemm #include <machine/pcb.h> 81d85631c4SPeter Wemm #include <machine/cpufunc.h> 82d41e41f9SJohn Baldwin #include <machine/trap.h> 83d85631c4SPeter Wemm 84d85631c4SPeter Wemm #ifdef COMPAT_FREEBSD4 859104847fSDavid Xu static void freebsd4_ia32_sendsig(sig_t, ksiginfo_t *, sigset_t *); 86d85631c4SPeter Wemm #endif 87d85631c4SPeter Wemm 88d85631c4SPeter Wemm static void 898c6f8f3dSKonstantin Belousov ia32_get_fpcontext(struct thread *td, struct ia32_mcontext *mcp, 90*bd9e0f5dSKonstantin Belousov char **xfpusave, size_t *xfpusave_len) 91d85631c4SPeter Wemm { 9207c80923SKonstantin Belousov /* 9307c80923SKonstantin Belousov * XXX Format of 64bit and 32bit FXSAVE areas differs. FXSAVE 9407c80923SKonstantin Belousov * in 32bit mode saves %cs and %ds, while on 64bit it saves 9507c80923SKonstantin Belousov * 64bit instruction and data pointers. Ignore the difference 9607c80923SKonstantin Belousov * for now, it should be irrelevant for most applications. 9707c80923SKonstantin Belousov */ 985c6eb037SKonstantin Belousov mcp->mc_ownedfp = fpugetregs(td); 99cb5bfd12SKonstantin Belousov bcopy(get_pcb_user_save_td(td), &mcp->mc_fpstate[0], 1005c6eb037SKonstantin Belousov sizeof(mcp->mc_fpstate)); 101bf2f09eeSPeter Wemm mcp->mc_fpformat = fpuformat(); 102*bd9e0f5dSKonstantin Belousov if (!use_xsave || cpu_max_ext_state_size <= sizeof(struct savefpu)) { 103*bd9e0f5dSKonstantin Belousov *xfpusave_len = 0; 104*bd9e0f5dSKonstantin Belousov *xfpusave = NULL; 105*bd9e0f5dSKonstantin Belousov } else { 10687b94d9aSKonstantin Belousov mcp->mc_flags |= _MC_IA32_HASFPXSTATE; 107*bd9e0f5dSKonstantin Belousov *xfpusave_len = mcp->mc_xfpustate_len = 108*bd9e0f5dSKonstantin Belousov cpu_max_ext_state_size - sizeof(struct savefpu); 109*bd9e0f5dSKonstantin Belousov *xfpusave = (char *)(get_pcb_user_save_td(td) + 1); 110*bd9e0f5dSKonstantin Belousov } 111d85631c4SPeter Wemm } 112d85631c4SPeter Wemm 113d85631c4SPeter Wemm static int 114206f09ebSKonstantin Belousov ia32_set_fpcontext(struct thread *td, struct ia32_mcontext *mcp, 1158c6f8f3dSKonstantin Belousov char *xfpustate, size_t xfpustate_len) 116d85631c4SPeter Wemm { 1178c6f8f3dSKonstantin Belousov int error; 118d85631c4SPeter Wemm 119d85631c4SPeter Wemm if (mcp->mc_fpformat == _MC_FPFMT_NODEV) 120d85631c4SPeter Wemm return (0); 121d85631c4SPeter Wemm else if (mcp->mc_fpformat != _MC_FPFMT_XMM) 122d85631c4SPeter Wemm return (EINVAL); 1238c6f8f3dSKonstantin Belousov else if (mcp->mc_ownedfp == _MC_FPOWNED_NONE) { 124d85631c4SPeter Wemm /* We don't care what state is left in the FPU or PCB. */ 125d85631c4SPeter Wemm fpstate_drop(td); 1268c6f8f3dSKonstantin Belousov error = 0; 1278c6f8f3dSKonstantin Belousov } else if (mcp->mc_ownedfp == _MC_FPOWNED_FPU || 128d85631c4SPeter Wemm mcp->mc_ownedfp == _MC_FPOWNED_PCB) { 1298c6f8f3dSKonstantin Belousov error = fpusetregs(td, (struct savefpu *)&mcp->mc_fpstate, 1308c6f8f3dSKonstantin Belousov xfpustate, xfpustate_len); 131d85631c4SPeter Wemm } else 132d85631c4SPeter Wemm return (EINVAL); 1338c6f8f3dSKonstantin Belousov return (error); 134d85631c4SPeter Wemm } 135d85631c4SPeter Wemm 136d85631c4SPeter Wemm /* 137add121a4SPeter Wemm * Get machine context. 138add121a4SPeter Wemm */ 139add121a4SPeter Wemm static int 140add121a4SPeter Wemm ia32_get_mcontext(struct thread *td, struct ia32_mcontext *mcp, int flags) 141add121a4SPeter Wemm { 142e6c006d9SJung-uk Kim struct pcb *pcb; 143add121a4SPeter Wemm struct trapframe *tp; 144add121a4SPeter Wemm 145e6c006d9SJung-uk Kim pcb = td->td_pcb; 146add121a4SPeter Wemm tp = td->td_frame; 147add121a4SPeter Wemm 148add121a4SPeter Wemm PROC_LOCK(curthread->td_proc); 149add121a4SPeter Wemm mcp->mc_onstack = sigonstack(tp->tf_rsp); 150add121a4SPeter Wemm PROC_UNLOCK(curthread->td_proc); 1512c66cccaSKonstantin Belousov /* Entry into kernel always sets TF_HASSEGS */ 1522c66cccaSKonstantin Belousov mcp->mc_gs = tp->tf_gs; 1532c66cccaSKonstantin Belousov mcp->mc_fs = tp->tf_fs; 1542c66cccaSKonstantin Belousov mcp->mc_es = tp->tf_es; 1552c66cccaSKonstantin Belousov mcp->mc_ds = tp->tf_ds; 156add121a4SPeter Wemm mcp->mc_edi = tp->tf_rdi; 157add121a4SPeter Wemm mcp->mc_esi = tp->tf_rsi; 158add121a4SPeter Wemm mcp->mc_ebp = tp->tf_rbp; 159add121a4SPeter Wemm mcp->mc_isp = tp->tf_rsp; 16094c6c6baSKonstantin Belousov mcp->mc_eflags = tp->tf_rflags; 161add121a4SPeter Wemm if (flags & GET_MC_CLEAR_RET) { 162add121a4SPeter Wemm mcp->mc_eax = 0; 163add121a4SPeter Wemm mcp->mc_edx = 0; 16494c6c6baSKonstantin Belousov mcp->mc_eflags &= ~PSL_C; 165add121a4SPeter Wemm } else { 166add121a4SPeter Wemm mcp->mc_eax = tp->tf_rax; 167add121a4SPeter Wemm mcp->mc_edx = tp->tf_rdx; 168add121a4SPeter Wemm } 169add121a4SPeter Wemm mcp->mc_ebx = tp->tf_rbx; 170add121a4SPeter Wemm mcp->mc_ecx = tp->tf_rcx; 171add121a4SPeter Wemm mcp->mc_eip = tp->tf_rip; 172add121a4SPeter Wemm mcp->mc_cs = tp->tf_cs; 173add121a4SPeter Wemm mcp->mc_esp = tp->tf_rsp; 174add121a4SPeter Wemm mcp->mc_ss = tp->tf_ss; 175add121a4SPeter Wemm mcp->mc_len = sizeof(*mcp); 1768c6f8f3dSKonstantin Belousov mcp->mc_flags = tp->tf_flags; 1778c6f8f3dSKonstantin Belousov ia32_get_fpcontext(td, mcp, NULL, 0); 178e6c006d9SJung-uk Kim mcp->mc_fsbase = pcb->pcb_fsbase; 179e6c006d9SJung-uk Kim mcp->mc_gsbase = pcb->pcb_gsbase; 1808c6f8f3dSKonstantin Belousov mcp->mc_xfpustate = 0; 1818c6f8f3dSKonstantin Belousov mcp->mc_xfpustate_len = 0; 1826f9ec5aaSKonstantin Belousov bzero(mcp->mc_spare2, sizeof(mcp->mc_spare2)); 183add121a4SPeter Wemm return (0); 184add121a4SPeter Wemm } 185add121a4SPeter Wemm 186add121a4SPeter Wemm /* 187add121a4SPeter Wemm * Set machine context. 188add121a4SPeter Wemm * 189add121a4SPeter Wemm * However, we don't set any but the user modifiable flags, and we won't 190add121a4SPeter Wemm * touch the cs selector. 191add121a4SPeter Wemm */ 192add121a4SPeter Wemm static int 193206f09ebSKonstantin Belousov ia32_set_mcontext(struct thread *td, struct ia32_mcontext *mcp) 194add121a4SPeter Wemm { 195add121a4SPeter Wemm struct trapframe *tp; 1968c6f8f3dSKonstantin Belousov char *xfpustate; 197add121a4SPeter Wemm long rflags; 198add121a4SPeter Wemm int ret; 199add121a4SPeter Wemm 200add121a4SPeter Wemm tp = td->td_frame; 201add121a4SPeter Wemm if (mcp->mc_len != sizeof(*mcp)) 202add121a4SPeter Wemm return (EINVAL); 203add121a4SPeter Wemm rflags = (mcp->mc_eflags & PSL_USERCHANGE) | 204add121a4SPeter Wemm (tp->tf_rflags & ~PSL_USERCHANGE); 2058c6f8f3dSKonstantin Belousov if (mcp->mc_flags & _MC_IA32_HASFPXSTATE) { 2068c6f8f3dSKonstantin Belousov if (mcp->mc_xfpustate_len > cpu_max_ext_state_size - 2078c6f8f3dSKonstantin Belousov sizeof(struct savefpu)) 2088c6f8f3dSKonstantin Belousov return (EINVAL); 209*bd9e0f5dSKonstantin Belousov xfpustate = (char *)fpu_save_area_alloc(); 2108c6f8f3dSKonstantin Belousov ret = copyin(PTRIN(mcp->mc_xfpustate), xfpustate, 2118c6f8f3dSKonstantin Belousov mcp->mc_xfpustate_len); 212*bd9e0f5dSKonstantin Belousov if (ret != 0) { 213*bd9e0f5dSKonstantin Belousov fpu_save_area_free((struct savefpu *)xfpustate); 2148c6f8f3dSKonstantin Belousov return (ret); 215*bd9e0f5dSKonstantin Belousov } 2168c6f8f3dSKonstantin Belousov } else 2178c6f8f3dSKonstantin Belousov xfpustate = NULL; 2188c6f8f3dSKonstantin Belousov ret = ia32_set_fpcontext(td, mcp, xfpustate, mcp->mc_xfpustate_len); 219*bd9e0f5dSKonstantin Belousov fpu_save_area_free((struct savefpu *)xfpustate); 220add121a4SPeter Wemm if (ret != 0) 221add121a4SPeter Wemm return (ret); 2222c66cccaSKonstantin Belousov tp->tf_gs = mcp->mc_gs; 223add121a4SPeter Wemm tp->tf_fs = mcp->mc_fs; 224add121a4SPeter Wemm tp->tf_es = mcp->mc_es; 225add121a4SPeter Wemm tp->tf_ds = mcp->mc_ds; 2262c66cccaSKonstantin Belousov tp->tf_flags = TF_HASSEGS; 227add121a4SPeter Wemm tp->tf_rdi = mcp->mc_edi; 228add121a4SPeter Wemm tp->tf_rsi = mcp->mc_esi; 229add121a4SPeter Wemm tp->tf_rbp = mcp->mc_ebp; 230add121a4SPeter Wemm tp->tf_rbx = mcp->mc_ebx; 231add121a4SPeter Wemm tp->tf_rdx = mcp->mc_edx; 232add121a4SPeter Wemm tp->tf_rcx = mcp->mc_ecx; 233add121a4SPeter Wemm tp->tf_rax = mcp->mc_eax; 234add121a4SPeter Wemm /* trapno, err */ 235add121a4SPeter Wemm tp->tf_rip = mcp->mc_eip; 236add121a4SPeter Wemm tp->tf_rflags = rflags; 237add121a4SPeter Wemm tp->tf_rsp = mcp->mc_esp; 238add121a4SPeter Wemm tp->tf_ss = mcp->mc_ss; 239e6c006d9SJung-uk Kim set_pcb_flags(td->td_pcb, PCB_FULL_IRET); 240add121a4SPeter Wemm return (0); 241add121a4SPeter Wemm } 242add121a4SPeter Wemm 243add121a4SPeter Wemm /* 244add121a4SPeter Wemm * The first two fields of a ucontext_t are the signal mask and 245add121a4SPeter Wemm * the machine context. The next field is uc_link; we want to 246add121a4SPeter Wemm * avoid destroying the link when copying out contexts. 247add121a4SPeter Wemm */ 248add121a4SPeter Wemm #define UC_COPY_SIZE offsetof(struct ia32_ucontext, uc_link) 249add121a4SPeter Wemm 250add121a4SPeter Wemm int 251add121a4SPeter Wemm freebsd32_getcontext(struct thread *td, struct freebsd32_getcontext_args *uap) 252add121a4SPeter Wemm { 253add121a4SPeter Wemm struct ia32_ucontext uc; 254add121a4SPeter Wemm int ret; 255add121a4SPeter Wemm 256add121a4SPeter Wemm if (uap->ucp == NULL) 257add121a4SPeter Wemm ret = EINVAL; 258add121a4SPeter Wemm else { 259f5e7d8bdSEric van Gyzen bzero(&uc, sizeof(uc)); 260add121a4SPeter Wemm ia32_get_mcontext(td, &uc.uc_mcontext, GET_MC_CLEAR_RET); 261add121a4SPeter Wemm PROC_LOCK(td->td_proc); 262add121a4SPeter Wemm uc.uc_sigmask = td->td_sigmask; 263add121a4SPeter Wemm PROC_UNLOCK(td->td_proc); 264add121a4SPeter Wemm ret = copyout(&uc, uap->ucp, UC_COPY_SIZE); 265add121a4SPeter Wemm } 266add121a4SPeter Wemm return (ret); 267add121a4SPeter Wemm } 268add121a4SPeter Wemm 269add121a4SPeter Wemm int 270add121a4SPeter Wemm freebsd32_setcontext(struct thread *td, struct freebsd32_setcontext_args *uap) 271add121a4SPeter Wemm { 272add121a4SPeter Wemm struct ia32_ucontext uc; 273add121a4SPeter Wemm int ret; 274add121a4SPeter Wemm 275add121a4SPeter Wemm if (uap->ucp == NULL) 276add121a4SPeter Wemm ret = EINVAL; 277add121a4SPeter Wemm else { 278add121a4SPeter Wemm ret = copyin(uap->ucp, &uc, UC_COPY_SIZE); 279add121a4SPeter Wemm if (ret == 0) { 280add121a4SPeter Wemm ret = ia32_set_mcontext(td, &uc.uc_mcontext); 281add121a4SPeter Wemm if (ret == 0) { 282d6e029adSKonstantin Belousov kern_sigprocmask(td, SIG_SETMASK, 283d6e029adSKonstantin Belousov &uc.uc_sigmask, NULL, 0); 284add121a4SPeter Wemm } 285add121a4SPeter Wemm } 286add121a4SPeter Wemm } 287add121a4SPeter Wemm return (ret == 0 ? EJUSTRETURN : ret); 288add121a4SPeter Wemm } 289add121a4SPeter Wemm 290add121a4SPeter Wemm int 291add121a4SPeter Wemm freebsd32_swapcontext(struct thread *td, struct freebsd32_swapcontext_args *uap) 292add121a4SPeter Wemm { 293add121a4SPeter Wemm struct ia32_ucontext uc; 294add121a4SPeter Wemm int ret; 295add121a4SPeter Wemm 296add121a4SPeter Wemm if (uap->oucp == NULL || uap->ucp == NULL) 297add121a4SPeter Wemm ret = EINVAL; 298add121a4SPeter Wemm else { 299f5e7d8bdSEric van Gyzen bzero(&uc, sizeof(uc)); 300add121a4SPeter Wemm ia32_get_mcontext(td, &uc.uc_mcontext, GET_MC_CLEAR_RET); 301add121a4SPeter Wemm PROC_LOCK(td->td_proc); 302add121a4SPeter Wemm uc.uc_sigmask = td->td_sigmask; 303add121a4SPeter Wemm PROC_UNLOCK(td->td_proc); 304add121a4SPeter Wemm ret = copyout(&uc, uap->oucp, UC_COPY_SIZE); 305add121a4SPeter Wemm if (ret == 0) { 306add121a4SPeter Wemm ret = copyin(uap->ucp, &uc, UC_COPY_SIZE); 307add121a4SPeter Wemm if (ret == 0) { 308add121a4SPeter Wemm ret = ia32_set_mcontext(td, &uc.uc_mcontext); 309add121a4SPeter Wemm if (ret == 0) { 310d6e029adSKonstantin Belousov kern_sigprocmask(td, SIG_SETMASK, 311d6e029adSKonstantin Belousov &uc.uc_sigmask, NULL, 0); 312add121a4SPeter Wemm } 313add121a4SPeter Wemm } 314add121a4SPeter Wemm } 315add121a4SPeter Wemm } 316add121a4SPeter Wemm return (ret == 0 ? EJUSTRETURN : ret); 317add121a4SPeter Wemm } 318add121a4SPeter Wemm 319add121a4SPeter Wemm /* 320d85631c4SPeter Wemm * Send an interrupt to process. 321d85631c4SPeter Wemm * 322d85631c4SPeter Wemm * Stack is set up to allow sigcode stored 323d85631c4SPeter Wemm * at top to call routine, followed by kcall 324d85631c4SPeter Wemm * to sigreturn routine below. After sigreturn 325d85631c4SPeter Wemm * resets the signal mask, the stack, and the 326d85631c4SPeter Wemm * frame pointer, it returns to the user 327d85631c4SPeter Wemm * specified pc, psl. 328d85631c4SPeter Wemm */ 3297332c129SKonstantin Belousov 3307332c129SKonstantin Belousov #ifdef COMPAT_43 3317332c129SKonstantin Belousov static void 3327332c129SKonstantin Belousov ia32_osendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask) 3337332c129SKonstantin Belousov { 3347332c129SKonstantin Belousov struct ia32_sigframe3 sf, *fp; 3357332c129SKonstantin Belousov struct proc *p; 3367332c129SKonstantin Belousov struct thread *td; 3377332c129SKonstantin Belousov struct sigacts *psp; 3387332c129SKonstantin Belousov struct trapframe *regs; 3397332c129SKonstantin Belousov int sig; 3407332c129SKonstantin Belousov int oonstack; 3417332c129SKonstantin Belousov 3427332c129SKonstantin Belousov td = curthread; 3437332c129SKonstantin Belousov p = td->td_proc; 3447332c129SKonstantin Belousov PROC_LOCK_ASSERT(p, MA_OWNED); 3457332c129SKonstantin Belousov sig = ksi->ksi_signo; 3467332c129SKonstantin Belousov psp = p->p_sigacts; 3477332c129SKonstantin Belousov mtx_assert(&psp->ps_mtx, MA_OWNED); 3487332c129SKonstantin Belousov regs = td->td_frame; 3497332c129SKonstantin Belousov oonstack = sigonstack(regs->tf_rsp); 3507332c129SKonstantin Belousov 3517332c129SKonstantin Belousov /* Allocate space for the signal handler context. */ 3527332c129SKonstantin Belousov if ((td->td_pflags & TDP_ALTSTACK) && !oonstack && 3537332c129SKonstantin Belousov SIGISMEMBER(psp->ps_sigonstack, sig)) { 354aa949be5SJohn Baldwin fp = (struct ia32_sigframe3 *)((uintptr_t)td->td_sigstk.ss_sp + 3557332c129SKonstantin Belousov td->td_sigstk.ss_size - sizeof(sf)); 3567332c129SKonstantin Belousov td->td_sigstk.ss_flags |= SS_ONSTACK; 3577332c129SKonstantin Belousov } else 3587332c129SKonstantin Belousov fp = (struct ia32_sigframe3 *)regs->tf_rsp - 1; 3597332c129SKonstantin Belousov 3607332c129SKonstantin Belousov /* Build the argument list for the signal handler. */ 3617332c129SKonstantin Belousov sf.sf_signum = sig; 3627332c129SKonstantin Belousov sf.sf_scp = (register_t)&fp->sf_siginfo.si_sc; 3632910a161SMark Johnston bzero(&sf.sf_siginfo, sizeof(sf.sf_siginfo)); 3647332c129SKonstantin Belousov if (SIGISMEMBER(psp->ps_siginfo, sig)) { 3657332c129SKonstantin Belousov /* Signal handler installed with SA_SIGINFO. */ 3667332c129SKonstantin Belousov sf.sf_arg2 = (register_t)&fp->sf_siginfo; 3677332c129SKonstantin Belousov sf.sf_siginfo.si_signo = sig; 3687332c129SKonstantin Belousov sf.sf_siginfo.si_code = ksi->ksi_code; 3697332c129SKonstantin Belousov sf.sf_ah = (uintptr_t)catcher; 3702910a161SMark Johnston sf.sf_addr = 0; 3717332c129SKonstantin Belousov } else { 3727332c129SKonstantin Belousov /* Old FreeBSD-style arguments. */ 3737332c129SKonstantin Belousov sf.sf_arg2 = ksi->ksi_code; 3747332c129SKonstantin Belousov sf.sf_addr = (register_t)ksi->ksi_addr; 3757332c129SKonstantin Belousov sf.sf_ah = (uintptr_t)catcher; 3767332c129SKonstantin Belousov } 3777332c129SKonstantin Belousov mtx_unlock(&psp->ps_mtx); 3787332c129SKonstantin Belousov PROC_UNLOCK(p); 3797332c129SKonstantin Belousov 3807332c129SKonstantin Belousov /* Save most if not all of trap frame. */ 3817332c129SKonstantin Belousov sf.sf_siginfo.si_sc.sc_eax = regs->tf_rax; 3827332c129SKonstantin Belousov sf.sf_siginfo.si_sc.sc_ebx = regs->tf_rbx; 3837332c129SKonstantin Belousov sf.sf_siginfo.si_sc.sc_ecx = regs->tf_rcx; 3847332c129SKonstantin Belousov sf.sf_siginfo.si_sc.sc_edx = regs->tf_rdx; 3857332c129SKonstantin Belousov sf.sf_siginfo.si_sc.sc_esi = regs->tf_rsi; 3867332c129SKonstantin Belousov sf.sf_siginfo.si_sc.sc_edi = regs->tf_rdi; 3877332c129SKonstantin Belousov sf.sf_siginfo.si_sc.sc_cs = regs->tf_cs; 3887332c129SKonstantin Belousov sf.sf_siginfo.si_sc.sc_ds = regs->tf_ds; 3897332c129SKonstantin Belousov sf.sf_siginfo.si_sc.sc_ss = regs->tf_ss; 3907332c129SKonstantin Belousov sf.sf_siginfo.si_sc.sc_es = regs->tf_es; 3917332c129SKonstantin Belousov sf.sf_siginfo.si_sc.sc_fs = regs->tf_fs; 3927332c129SKonstantin Belousov sf.sf_siginfo.si_sc.sc_gs = regs->tf_gs; 3937332c129SKonstantin Belousov sf.sf_siginfo.si_sc.sc_isp = regs->tf_rsp; 3947332c129SKonstantin Belousov 3957332c129SKonstantin Belousov /* Build the signal context to be used by osigreturn(). */ 3967332c129SKonstantin Belousov sf.sf_siginfo.si_sc.sc_onstack = (oonstack) ? 1 : 0; 3977332c129SKonstantin Belousov SIG2OSIG(*mask, sf.sf_siginfo.si_sc.sc_mask); 3987332c129SKonstantin Belousov sf.sf_siginfo.si_sc.sc_esp = regs->tf_rsp; 3997332c129SKonstantin Belousov sf.sf_siginfo.si_sc.sc_ebp = regs->tf_rbp; 4007332c129SKonstantin Belousov sf.sf_siginfo.si_sc.sc_eip = regs->tf_rip; 4017332c129SKonstantin Belousov sf.sf_siginfo.si_sc.sc_eflags = regs->tf_rflags; 4027332c129SKonstantin Belousov sf.sf_siginfo.si_sc.sc_trapno = regs->tf_trapno; 4037332c129SKonstantin Belousov sf.sf_siginfo.si_sc.sc_err = regs->tf_err; 4047332c129SKonstantin Belousov 4057332c129SKonstantin Belousov /* 4067332c129SKonstantin Belousov * Copy the sigframe out to the user's stack. 4077332c129SKonstantin Belousov */ 4087332c129SKonstantin Belousov if (copyout(&sf, fp, sizeof(*fp)) != 0) { 4097332c129SKonstantin Belousov #ifdef DEBUG 4107332c129SKonstantin Belousov printf("process %ld has trashed its stack\n", (long)p->p_pid); 4117332c129SKonstantin Belousov #endif 4127332c129SKonstantin Belousov PROC_LOCK(p); 4137332c129SKonstantin Belousov sigexit(td, SIGILL); 4147332c129SKonstantin Belousov } 4157332c129SKonstantin Belousov 4167332c129SKonstantin Belousov regs->tf_rsp = (uintptr_t)fp; 4177332c129SKonstantin Belousov regs->tf_rip = p->p_sysent->sv_psstrings - sz_ia32_osigcode; 4187332c129SKonstantin Belousov regs->tf_rflags &= ~(PSL_T | PSL_D); 4197332c129SKonstantin Belousov regs->tf_cs = _ucode32sel; 4207332c129SKonstantin Belousov regs->tf_ds = _udatasel; 4217332c129SKonstantin Belousov regs->tf_es = _udatasel; 4227332c129SKonstantin Belousov regs->tf_fs = _udatasel; 4237332c129SKonstantin Belousov regs->tf_ss = _udatasel; 4247332c129SKonstantin Belousov set_pcb_flags(td->td_pcb, PCB_FULL_IRET); 4257332c129SKonstantin Belousov PROC_LOCK(p); 4267332c129SKonstantin Belousov mtx_lock(&psp->ps_mtx); 4277332c129SKonstantin Belousov } 4287332c129SKonstantin Belousov #endif 4297332c129SKonstantin Belousov 430d85631c4SPeter Wemm #ifdef COMPAT_FREEBSD4 431d85631c4SPeter Wemm static void 4329104847fSDavid Xu freebsd4_ia32_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask) 433d85631c4SPeter Wemm { 434d85631c4SPeter Wemm struct ia32_sigframe4 sf, *sfp; 435c6511aeaSDavid Xu struct siginfo32 siginfo; 436d85631c4SPeter Wemm struct proc *p; 437d85631c4SPeter Wemm struct thread *td; 438d85631c4SPeter Wemm struct sigacts *psp; 439d85631c4SPeter Wemm struct trapframe *regs; 440d85631c4SPeter Wemm int oonstack; 4419104847fSDavid Xu int sig; 442d85631c4SPeter Wemm 443d85631c4SPeter Wemm td = curthread; 444d85631c4SPeter Wemm p = td->td_proc; 445c6511aeaSDavid Xu siginfo_to_siginfo32(&ksi->ksi_info, &siginfo); 4469104847fSDavid Xu 447d85631c4SPeter Wemm PROC_LOCK_ASSERT(p, MA_OWNED); 4489104847fSDavid Xu sig = siginfo.si_signo; 449d85631c4SPeter Wemm psp = p->p_sigacts; 4503554ecf0SPeter Wemm mtx_assert(&psp->ps_mtx, MA_OWNED); 451d85631c4SPeter Wemm regs = td->td_frame; 452d85631c4SPeter Wemm oonstack = sigonstack(regs->tf_rsp); 453d85631c4SPeter Wemm 454d85631c4SPeter Wemm /* Save user context. */ 455d85631c4SPeter Wemm bzero(&sf, sizeof(sf)); 456d85631c4SPeter Wemm sf.sf_uc.uc_sigmask = *mask; 457a30ec4b9SDavid Xu sf.sf_uc.uc_stack.ss_sp = (uintptr_t)td->td_sigstk.ss_sp; 458a30ec4b9SDavid Xu sf.sf_uc.uc_stack.ss_size = td->td_sigstk.ss_size; 459a30ec4b9SDavid Xu sf.sf_uc.uc_stack.ss_flags = (td->td_pflags & TDP_ALTSTACK) 460d85631c4SPeter Wemm ? ((oonstack) ? SS_ONSTACK : 0) : SS_DISABLE; 461d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_onstack = (oonstack) ? 1 : 0; 462d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_edi = regs->tf_rdi; 463d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_esi = regs->tf_rsi; 464d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_ebp = regs->tf_rbp; 465d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_isp = regs->tf_rsp; /* XXX */ 466d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_ebx = regs->tf_rbx; 467d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_edx = regs->tf_rdx; 468d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_ecx = regs->tf_rcx; 469d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_eax = regs->tf_rax; 470d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_trapno = regs->tf_trapno; 471d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_err = regs->tf_err; 472d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_eip = regs->tf_rip; 473d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_cs = regs->tf_cs; 474d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_eflags = regs->tf_rflags; 475d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_esp = regs->tf_rsp; 476d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_ss = regs->tf_ss; 4772c66cccaSKonstantin Belousov sf.sf_uc.uc_mcontext.mc_ds = regs->tf_ds; 4782c66cccaSKonstantin Belousov sf.sf_uc.uc_mcontext.mc_es = regs->tf_es; 4792c66cccaSKonstantin Belousov sf.sf_uc.uc_mcontext.mc_fs = regs->tf_fs; 4802c66cccaSKonstantin Belousov sf.sf_uc.uc_mcontext.mc_gs = regs->tf_gs; 4816f9ec5aaSKonstantin Belousov bzero(sf.sf_uc.uc_mcontext.mc_fpregs, 4826f9ec5aaSKonstantin Belousov sizeof(sf.sf_uc.uc_mcontext.mc_fpregs)); 4836f9ec5aaSKonstantin Belousov bzero(sf.sf_uc.uc_mcontext.__spare__, 4846f9ec5aaSKonstantin Belousov sizeof(sf.sf_uc.uc_mcontext.__spare__)); 4856f9ec5aaSKonstantin Belousov bzero(sf.sf_uc.__spare__, sizeof(sf.sf_uc.__spare__)); 486d85631c4SPeter Wemm 487d85631c4SPeter Wemm /* Allocate space for the signal handler context. */ 488a30ec4b9SDavid Xu if ((td->td_pflags & TDP_ALTSTACK) != 0 && !oonstack && 489d85631c4SPeter Wemm SIGISMEMBER(psp->ps_sigonstack, sig)) { 490aa949be5SJohn Baldwin sfp = (struct ia32_sigframe4 *)((uintptr_t)td->td_sigstk.ss_sp + 491a30ec4b9SDavid Xu td->td_sigstk.ss_size - sizeof(sf)); 492d85631c4SPeter Wemm } else 493d85631c4SPeter Wemm sfp = (struct ia32_sigframe4 *)regs->tf_rsp - 1; 494d85631c4SPeter Wemm PROC_UNLOCK(p); 495d85631c4SPeter Wemm 496d85631c4SPeter Wemm /* Build the argument list for the signal handler. */ 497d85631c4SPeter Wemm sf.sf_signum = sig; 498d85631c4SPeter Wemm sf.sf_ucontext = (register_t)&sfp->sf_uc; 4996f9ec5aaSKonstantin Belousov bzero(&sf.sf_si, sizeof(sf.sf_si)); 5004fa84e0fSPeter Wemm if (SIGISMEMBER(psp->ps_siginfo, sig)) { 501d85631c4SPeter Wemm /* Signal handler installed with SA_SIGINFO. */ 502d85631c4SPeter Wemm sf.sf_siginfo = (u_int32_t)(uintptr_t)&sfp->sf_si; 503d85631c4SPeter Wemm sf.sf_ah = (u_int32_t)(uintptr_t)catcher; 504d85631c4SPeter Wemm 505d85631c4SPeter Wemm /* Fill in POSIX parts */ 5069104847fSDavid Xu sf.sf_si = siginfo; 507d85631c4SPeter Wemm sf.sf_si.si_signo = sig; 508d85631c4SPeter Wemm } else { 509d85631c4SPeter Wemm /* Old FreeBSD-style arguments. */ 5109104847fSDavid Xu sf.sf_siginfo = siginfo.si_code; 5119104847fSDavid Xu sf.sf_addr = (u_int32_t)siginfo.si_addr; 512d85631c4SPeter Wemm sf.sf_ah = (u_int32_t)(uintptr_t)catcher; 513d85631c4SPeter Wemm } 5143554ecf0SPeter Wemm mtx_unlock(&psp->ps_mtx); 515d85631c4SPeter Wemm 516d85631c4SPeter Wemm /* 517d85631c4SPeter Wemm * Copy the sigframe out to the user's stack. 518d85631c4SPeter Wemm */ 519d85631c4SPeter Wemm if (copyout(&sf, sfp, sizeof(*sfp)) != 0) { 520d85631c4SPeter Wemm #ifdef DEBUG 521d85631c4SPeter Wemm printf("process %ld has trashed its stack\n", (long)p->p_pid); 522d85631c4SPeter Wemm #endif 523d85631c4SPeter Wemm PROC_LOCK(p); 524d85631c4SPeter Wemm sigexit(td, SIGILL); 525d85631c4SPeter Wemm } 526d85631c4SPeter Wemm 527d85631c4SPeter Wemm regs->tf_rsp = (uintptr_t)sfp; 5286297a3d8SKonstantin Belousov regs->tf_rip = p->p_sysent->sv_sigcode_base + sz_ia32_sigcode - 5296297a3d8SKonstantin Belousov sz_freebsd4_ia32_sigcode; 53022eca0bfSKonstantin Belousov regs->tf_rflags &= ~(PSL_T | PSL_D); 531d85631c4SPeter Wemm regs->tf_cs = _ucode32sel; 532d85631c4SPeter Wemm regs->tf_ss = _udatasel; 5332c66cccaSKonstantin Belousov regs->tf_ds = _udatasel; 5342c66cccaSKonstantin Belousov regs->tf_es = _udatasel; 535e6c006d9SJung-uk Kim set_pcb_flags(td->td_pcb, PCB_FULL_IRET); 536d85631c4SPeter Wemm /* leave user %fs and %gs untouched */ 537d85631c4SPeter Wemm PROC_LOCK(p); 5383554ecf0SPeter Wemm mtx_lock(&psp->ps_mtx); 539d85631c4SPeter Wemm } 540d85631c4SPeter Wemm #endif /* COMPAT_FREEBSD4 */ 541d85631c4SPeter Wemm 542d85631c4SPeter Wemm void 5439104847fSDavid Xu ia32_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask) 544d85631c4SPeter Wemm { 545d85631c4SPeter Wemm struct ia32_sigframe sf, *sfp; 546c6511aeaSDavid Xu struct siginfo32 siginfo; 547d85631c4SPeter Wemm struct proc *p; 548d85631c4SPeter Wemm struct thread *td; 549d85631c4SPeter Wemm struct sigacts *psp; 550d85631c4SPeter Wemm char *sp; 551d85631c4SPeter Wemm struct trapframe *regs; 5528c6f8f3dSKonstantin Belousov char *xfpusave; 5538c6f8f3dSKonstantin Belousov size_t xfpusave_len; 554d85631c4SPeter Wemm int oonstack; 5559104847fSDavid Xu int sig; 556d85631c4SPeter Wemm 557c6511aeaSDavid Xu siginfo_to_siginfo32(&ksi->ksi_info, &siginfo); 558d85631c4SPeter Wemm td = curthread; 559d85631c4SPeter Wemm p = td->td_proc; 560d85631c4SPeter Wemm PROC_LOCK_ASSERT(p, MA_OWNED); 5619104847fSDavid Xu sig = siginfo.si_signo; 562d85631c4SPeter Wemm psp = p->p_sigacts; 563d85631c4SPeter Wemm #ifdef COMPAT_FREEBSD4 564d85631c4SPeter Wemm if (SIGISMEMBER(psp->ps_freebsd4, sig)) { 5659104847fSDavid Xu freebsd4_ia32_sendsig(catcher, ksi, mask); 566d85631c4SPeter Wemm return; 567d85631c4SPeter Wemm } 568d85631c4SPeter Wemm #endif 5697332c129SKonstantin Belousov #ifdef COMPAT_43 5707332c129SKonstantin Belousov if (SIGISMEMBER(psp->ps_osigset, sig)) { 5717332c129SKonstantin Belousov ia32_osendsig(catcher, ksi, mask); 5727332c129SKonstantin Belousov return; 5737332c129SKonstantin Belousov } 5747332c129SKonstantin Belousov #endif 5753554ecf0SPeter Wemm mtx_assert(&psp->ps_mtx, MA_OWNED); 576d85631c4SPeter Wemm regs = td->td_frame; 577d85631c4SPeter Wemm oonstack = sigonstack(regs->tf_rsp); 578d85631c4SPeter Wemm 579d85631c4SPeter Wemm /* Save user context. */ 580d85631c4SPeter Wemm bzero(&sf, sizeof(sf)); 581d85631c4SPeter Wemm sf.sf_uc.uc_sigmask = *mask; 582a30ec4b9SDavid Xu sf.sf_uc.uc_stack.ss_sp = (uintptr_t)td->td_sigstk.ss_sp; 583a30ec4b9SDavid Xu sf.sf_uc.uc_stack.ss_size = td->td_sigstk.ss_size; 584a30ec4b9SDavid Xu sf.sf_uc.uc_stack.ss_flags = (td->td_pflags & TDP_ALTSTACK) 585d85631c4SPeter Wemm ? ((oonstack) ? SS_ONSTACK : 0) : SS_DISABLE; 586d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_onstack = (oonstack) ? 1 : 0; 587d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_edi = regs->tf_rdi; 588d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_esi = regs->tf_rsi; 589d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_ebp = regs->tf_rbp; 590d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_isp = regs->tf_rsp; /* XXX */ 591d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_ebx = regs->tf_rbx; 592d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_edx = regs->tf_rdx; 593d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_ecx = regs->tf_rcx; 594d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_eax = regs->tf_rax; 595d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_trapno = regs->tf_trapno; 596d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_err = regs->tf_err; 597d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_eip = regs->tf_rip; 598d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_cs = regs->tf_cs; 599d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_eflags = regs->tf_rflags; 600d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_esp = regs->tf_rsp; 601d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_ss = regs->tf_ss; 6022c66cccaSKonstantin Belousov sf.sf_uc.uc_mcontext.mc_ds = regs->tf_ds; 6032c66cccaSKonstantin Belousov sf.sf_uc.uc_mcontext.mc_es = regs->tf_es; 6042c66cccaSKonstantin Belousov sf.sf_uc.uc_mcontext.mc_fs = regs->tf_fs; 6052c66cccaSKonstantin Belousov sf.sf_uc.uc_mcontext.mc_gs = regs->tf_gs; 606d85631c4SPeter Wemm sf.sf_uc.uc_mcontext.mc_len = sizeof(sf.sf_uc.uc_mcontext); /* magic */ 607*bd9e0f5dSKonstantin Belousov ia32_get_fpcontext(td, &sf.sf_uc.uc_mcontext, &xfpusave, &xfpusave_len); 608d85631c4SPeter Wemm fpstate_drop(td); 6092c66cccaSKonstantin Belousov sf.sf_uc.uc_mcontext.mc_fsbase = td->td_pcb->pcb_fsbase; 6102c66cccaSKonstantin Belousov sf.sf_uc.uc_mcontext.mc_gsbase = td->td_pcb->pcb_gsbase; 611d85631c4SPeter Wemm 612d85631c4SPeter Wemm /* Allocate space for the signal handler context. */ 613a30ec4b9SDavid Xu if ((td->td_pflags & TDP_ALTSTACK) != 0 && !oonstack && 6148c6f8f3dSKonstantin Belousov SIGISMEMBER(psp->ps_sigonstack, sig)) 615aa949be5SJohn Baldwin sp = (char *)td->td_sigstk.ss_sp + td->td_sigstk.ss_size; 6168c6f8f3dSKonstantin Belousov else 6178c6f8f3dSKonstantin Belousov sp = (char *)regs->tf_rsp; 6188c6f8f3dSKonstantin Belousov if (xfpusave != NULL) { 6198c6f8f3dSKonstantin Belousov sp -= xfpusave_len; 6208c6f8f3dSKonstantin Belousov sp = (char *)((unsigned long)sp & ~0x3Ful); 6218c6f8f3dSKonstantin Belousov sf.sf_uc.uc_mcontext.mc_xfpustate = (register_t)sp; 6228c6f8f3dSKonstantin Belousov } 6238c6f8f3dSKonstantin Belousov sp -= sizeof(sf); 624d85631c4SPeter Wemm /* Align to 16 bytes. */ 625d85631c4SPeter Wemm sfp = (struct ia32_sigframe *)((uintptr_t)sp & ~0xF); 626d85631c4SPeter Wemm PROC_UNLOCK(p); 627d85631c4SPeter Wemm 628d85631c4SPeter Wemm /* Build the argument list for the signal handler. */ 629d85631c4SPeter Wemm sf.sf_signum = sig; 630d85631c4SPeter Wemm sf.sf_ucontext = (register_t)&sfp->sf_uc; 6316f9ec5aaSKonstantin Belousov bzero(&sf.sf_si, sizeof(sf.sf_si)); 6324fa84e0fSPeter Wemm if (SIGISMEMBER(psp->ps_siginfo, sig)) { 633d85631c4SPeter Wemm /* Signal handler installed with SA_SIGINFO. */ 634d85631c4SPeter Wemm sf.sf_siginfo = (u_int32_t)(uintptr_t)&sfp->sf_si; 635d85631c4SPeter Wemm sf.sf_ah = (u_int32_t)(uintptr_t)catcher; 636d85631c4SPeter Wemm 637d85631c4SPeter Wemm /* Fill in POSIX parts */ 6389104847fSDavid Xu sf.sf_si = siginfo; 639d85631c4SPeter Wemm sf.sf_si.si_signo = sig; 640d85631c4SPeter Wemm } else { 641d85631c4SPeter Wemm /* Old FreeBSD-style arguments. */ 6429104847fSDavid Xu sf.sf_siginfo = siginfo.si_code; 6439104847fSDavid Xu sf.sf_addr = (u_int32_t)siginfo.si_addr; 644d85631c4SPeter Wemm sf.sf_ah = (u_int32_t)(uintptr_t)catcher; 645d85631c4SPeter Wemm } 6463554ecf0SPeter Wemm mtx_unlock(&psp->ps_mtx); 647d85631c4SPeter Wemm 648d85631c4SPeter Wemm /* 649d85631c4SPeter Wemm * Copy the sigframe out to the user's stack. 650d85631c4SPeter Wemm */ 6518c6f8f3dSKonstantin Belousov if (copyout(&sf, sfp, sizeof(*sfp)) != 0 || 6528c6f8f3dSKonstantin Belousov (xfpusave != NULL && copyout(xfpusave, 6538c6f8f3dSKonstantin Belousov PTRIN(sf.sf_uc.uc_mcontext.mc_xfpustate), xfpusave_len) 6548c6f8f3dSKonstantin Belousov != 0)) { 655d85631c4SPeter Wemm #ifdef DEBUG 656d85631c4SPeter Wemm printf("process %ld has trashed its stack\n", (long)p->p_pid); 657d85631c4SPeter Wemm #endif 658d85631c4SPeter Wemm PROC_LOCK(p); 659d85631c4SPeter Wemm sigexit(td, SIGILL); 660d85631c4SPeter Wemm } 661d85631c4SPeter Wemm 662d85631c4SPeter Wemm regs->tf_rsp = (uintptr_t)sfp; 6636297a3d8SKonstantin Belousov regs->tf_rip = p->p_sysent->sv_sigcode_base; 66422eca0bfSKonstantin Belousov regs->tf_rflags &= ~(PSL_T | PSL_D); 665d85631c4SPeter Wemm regs->tf_cs = _ucode32sel; 666d85631c4SPeter Wemm regs->tf_ss = _udatasel; 6672c66cccaSKonstantin Belousov regs->tf_ds = _udatasel; 6682c66cccaSKonstantin Belousov regs->tf_es = _udatasel; 669e6c006d9SJung-uk Kim set_pcb_flags(td->td_pcb, PCB_FULL_IRET); 6702c66cccaSKonstantin Belousov /* XXXKIB leave user %fs and %gs untouched */ 671d85631c4SPeter Wemm PROC_LOCK(p); 6723554ecf0SPeter Wemm mtx_lock(&psp->ps_mtx); 673d85631c4SPeter Wemm } 674d85631c4SPeter Wemm 675d85631c4SPeter Wemm /* 676d85631c4SPeter Wemm * System call to cleanup state after a signal 677d85631c4SPeter Wemm * has been taken. Reset signal mask and 678d85631c4SPeter Wemm * stack state from context left by sendsig (above). 679d85631c4SPeter Wemm * Return to previous pc and psl as specified by 680d85631c4SPeter Wemm * context left by sendsig. Check carefully to 681d85631c4SPeter Wemm * make sure that the user has not modified the 682d85631c4SPeter Wemm * state to gain improper privileges. 683d85631c4SPeter Wemm */ 6847332c129SKonstantin Belousov 6857332c129SKonstantin Belousov #ifdef COMPAT_43 6867332c129SKonstantin Belousov int 6877332c129SKonstantin Belousov ofreebsd32_sigreturn(struct thread *td, struct ofreebsd32_sigreturn_args *uap) 6887332c129SKonstantin Belousov { 6897332c129SKonstantin Belousov struct ia32_sigcontext3 sc, *scp; 6907332c129SKonstantin Belousov struct trapframe *regs; 6917332c129SKonstantin Belousov int eflags, error; 6927332c129SKonstantin Belousov ksiginfo_t ksi; 6937332c129SKonstantin Belousov 6947332c129SKonstantin Belousov regs = td->td_frame; 6957332c129SKonstantin Belousov error = copyin(uap->sigcntxp, &sc, sizeof(sc)); 6967332c129SKonstantin Belousov if (error != 0) 6977332c129SKonstantin Belousov return (error); 6987332c129SKonstantin Belousov scp = ≻ 6997332c129SKonstantin Belousov eflags = scp->sc_eflags; 7003d271aaaSEd Maste if (!EFL_SECURE(eflags, regs->tf_rflags)) { 7017332c129SKonstantin Belousov return (EINVAL); 7027332c129SKonstantin Belousov } 7037332c129SKonstantin Belousov if (!CS_SECURE(scp->sc_cs)) { 7047332c129SKonstantin Belousov ksiginfo_init_trap(&ksi); 7057332c129SKonstantin Belousov ksi.ksi_signo = SIGBUS; 7067332c129SKonstantin Belousov ksi.ksi_code = BUS_OBJERR; 7077332c129SKonstantin Belousov ksi.ksi_trapno = T_PROTFLT; 7087332c129SKonstantin Belousov ksi.ksi_addr = (void *)regs->tf_rip; 7097332c129SKonstantin Belousov trapsignal(td, &ksi); 7107332c129SKonstantin Belousov return (EINVAL); 7117332c129SKonstantin Belousov } 7127332c129SKonstantin Belousov regs->tf_ds = scp->sc_ds; 7137332c129SKonstantin Belousov regs->tf_es = scp->sc_es; 7147332c129SKonstantin Belousov regs->tf_fs = scp->sc_fs; 7157332c129SKonstantin Belousov regs->tf_gs = scp->sc_gs; 7167332c129SKonstantin Belousov 7177332c129SKonstantin Belousov regs->tf_rax = scp->sc_eax; 7187332c129SKonstantin Belousov regs->tf_rbx = scp->sc_ebx; 7197332c129SKonstantin Belousov regs->tf_rcx = scp->sc_ecx; 7207332c129SKonstantin Belousov regs->tf_rdx = scp->sc_edx; 7217332c129SKonstantin Belousov regs->tf_rsi = scp->sc_esi; 7227332c129SKonstantin Belousov regs->tf_rdi = scp->sc_edi; 7237332c129SKonstantin Belousov regs->tf_cs = scp->sc_cs; 7247332c129SKonstantin Belousov regs->tf_ss = scp->sc_ss; 7257332c129SKonstantin Belousov regs->tf_rbp = scp->sc_ebp; 7267332c129SKonstantin Belousov regs->tf_rsp = scp->sc_esp; 7277332c129SKonstantin Belousov regs->tf_rip = scp->sc_eip; 7287332c129SKonstantin Belousov regs->tf_rflags = eflags; 7297332c129SKonstantin Belousov 7307332c129SKonstantin Belousov if (scp->sc_onstack & 1) 7317332c129SKonstantin Belousov td->td_sigstk.ss_flags |= SS_ONSTACK; 7327332c129SKonstantin Belousov else 7337332c129SKonstantin Belousov td->td_sigstk.ss_flags &= ~SS_ONSTACK; 7347332c129SKonstantin Belousov 7357332c129SKonstantin Belousov kern_sigprocmask(td, SIG_SETMASK, (sigset_t *)&scp->sc_mask, NULL, 7367332c129SKonstantin Belousov SIGPROCMASK_OLD); 7377332c129SKonstantin Belousov set_pcb_flags(td->td_pcb, PCB_FULL_IRET); 7387332c129SKonstantin Belousov return (EJUSTRETURN); 7397332c129SKonstantin Belousov } 7407332c129SKonstantin Belousov #endif 7417332c129SKonstantin Belousov 742d85631c4SPeter Wemm #ifdef COMPAT_FREEBSD4 743d85631c4SPeter Wemm /* 744d85631c4SPeter Wemm * MPSAFE 745d85631c4SPeter Wemm */ 746d85631c4SPeter Wemm int 74746159d1fSPeter Wemm freebsd4_freebsd32_sigreturn(td, uap) 748d85631c4SPeter Wemm struct thread *td; 74946159d1fSPeter Wemm struct freebsd4_freebsd32_sigreturn_args /* { 75046159d1fSPeter Wemm const struct freebsd4_freebsd32_ucontext *sigcntxp; 751d85631c4SPeter Wemm } */ *uap; 752d85631c4SPeter Wemm { 753d85631c4SPeter Wemm struct ia32_ucontext4 uc; 754d85631c4SPeter Wemm struct trapframe *regs; 755d6e029adSKonstantin Belousov struct ia32_ucontext4 *ucp; 756d85631c4SPeter Wemm int cs, eflags, error; 7579104847fSDavid Xu ksiginfo_t ksi; 758d85631c4SPeter Wemm 759d85631c4SPeter Wemm error = copyin(uap->sigcntxp, &uc, sizeof(uc)); 760d85631c4SPeter Wemm if (error != 0) 761d85631c4SPeter Wemm return (error); 762d85631c4SPeter Wemm ucp = &uc; 763d85631c4SPeter Wemm regs = td->td_frame; 764d85631c4SPeter Wemm eflags = ucp->uc_mcontext.mc_eflags; 765d85631c4SPeter Wemm /* 766d85631c4SPeter Wemm * Don't allow users to change privileged or reserved flags. 767d85631c4SPeter Wemm */ 7683d271aaaSEd Maste if (!EFL_SECURE(eflags, regs->tf_rflags)) { 7695f82d16eSKonstantin Belousov uprintf("pid %d (%s): freebsd4_freebsd32_sigreturn eflags = 0x%x\n", 7705f82d16eSKonstantin Belousov td->td_proc->p_pid, td->td_name, eflags); 771d85631c4SPeter Wemm return (EINVAL); 772d85631c4SPeter Wemm } 773d85631c4SPeter Wemm 774d85631c4SPeter Wemm /* 775d85631c4SPeter Wemm * Don't allow users to load a valid privileged %cs. Let the 776d85631c4SPeter Wemm * hardware check for invalid selectors, excess privilege in 777d85631c4SPeter Wemm * other selectors, invalid %eip's and invalid %esp's. 778d85631c4SPeter Wemm */ 779d85631c4SPeter Wemm cs = ucp->uc_mcontext.mc_cs; 780d85631c4SPeter Wemm if (!CS_SECURE(cs)) { 7815f82d16eSKonstantin Belousov uprintf("pid %d (%s): freebsd4_sigreturn cs = 0x%x\n", 7825f82d16eSKonstantin Belousov td->td_proc->p_pid, td->td_name, cs); 7839104847fSDavid Xu ksiginfo_init_trap(&ksi); 7849104847fSDavid Xu ksi.ksi_signo = SIGBUS; 7859104847fSDavid Xu ksi.ksi_code = BUS_OBJERR; 7869104847fSDavid Xu ksi.ksi_trapno = T_PROTFLT; 7879104847fSDavid Xu ksi.ksi_addr = (void *)regs->tf_rip; 7889104847fSDavid Xu trapsignal(td, &ksi); 789d85631c4SPeter Wemm return (EINVAL); 790d85631c4SPeter Wemm } 791d85631c4SPeter Wemm 792d85631c4SPeter Wemm regs->tf_rdi = ucp->uc_mcontext.mc_edi; 793d85631c4SPeter Wemm regs->tf_rsi = ucp->uc_mcontext.mc_esi; 794d85631c4SPeter Wemm regs->tf_rbp = ucp->uc_mcontext.mc_ebp; 795d85631c4SPeter Wemm regs->tf_rbx = ucp->uc_mcontext.mc_ebx; 796d85631c4SPeter Wemm regs->tf_rdx = ucp->uc_mcontext.mc_edx; 797d85631c4SPeter Wemm regs->tf_rcx = ucp->uc_mcontext.mc_ecx; 798d85631c4SPeter Wemm regs->tf_rax = ucp->uc_mcontext.mc_eax; 799d85631c4SPeter Wemm regs->tf_trapno = ucp->uc_mcontext.mc_trapno; 800d85631c4SPeter Wemm regs->tf_err = ucp->uc_mcontext.mc_err; 801d85631c4SPeter Wemm regs->tf_rip = ucp->uc_mcontext.mc_eip; 802d85631c4SPeter Wemm regs->tf_cs = cs; 803d85631c4SPeter Wemm regs->tf_rflags = ucp->uc_mcontext.mc_eflags; 804d85631c4SPeter Wemm regs->tf_rsp = ucp->uc_mcontext.mc_esp; 805d85631c4SPeter Wemm regs->tf_ss = ucp->uc_mcontext.mc_ss; 8062c66cccaSKonstantin Belousov regs->tf_ds = ucp->uc_mcontext.mc_ds; 8072c66cccaSKonstantin Belousov regs->tf_es = ucp->uc_mcontext.mc_es; 8082c66cccaSKonstantin Belousov regs->tf_fs = ucp->uc_mcontext.mc_fs; 8092c66cccaSKonstantin Belousov regs->tf_gs = ucp->uc_mcontext.mc_gs; 810d85631c4SPeter Wemm 811d6e029adSKonstantin Belousov kern_sigprocmask(td, SIG_SETMASK, &ucp->uc_sigmask, NULL, 0); 812e6c006d9SJung-uk Kim set_pcb_flags(td->td_pcb, PCB_FULL_IRET); 813d85631c4SPeter Wemm return (EJUSTRETURN); 814d85631c4SPeter Wemm } 815d85631c4SPeter Wemm #endif /* COMPAT_FREEBSD4 */ 816d85631c4SPeter Wemm 817d85631c4SPeter Wemm /* 818d85631c4SPeter Wemm * MPSAFE 819d85631c4SPeter Wemm */ 820d85631c4SPeter Wemm int 82146159d1fSPeter Wemm freebsd32_sigreturn(td, uap) 822d85631c4SPeter Wemm struct thread *td; 82346159d1fSPeter Wemm struct freebsd32_sigreturn_args /* { 82446159d1fSPeter Wemm const struct freebsd32_ucontext *sigcntxp; 825d85631c4SPeter Wemm } */ *uap; 826d85631c4SPeter Wemm { 827d85631c4SPeter Wemm struct ia32_ucontext uc; 828d85631c4SPeter Wemm struct trapframe *regs; 829d6e029adSKonstantin Belousov struct ia32_ucontext *ucp; 8308c6f8f3dSKonstantin Belousov char *xfpustate; 8318c6f8f3dSKonstantin Belousov size_t xfpustate_len; 832d85631c4SPeter Wemm int cs, eflags, error, ret; 8339104847fSDavid Xu ksiginfo_t ksi; 834d85631c4SPeter Wemm 835d85631c4SPeter Wemm error = copyin(uap->sigcntxp, &uc, sizeof(uc)); 836d85631c4SPeter Wemm if (error != 0) 837d85631c4SPeter Wemm return (error); 838d85631c4SPeter Wemm ucp = &uc; 839d85631c4SPeter Wemm regs = td->td_frame; 840d85631c4SPeter Wemm eflags = ucp->uc_mcontext.mc_eflags; 841d85631c4SPeter Wemm /* 842d85631c4SPeter Wemm * Don't allow users to change privileged or reserved flags. 843d85631c4SPeter Wemm */ 8443d271aaaSEd Maste if (!EFL_SECURE(eflags, regs->tf_rflags)) { 8455f82d16eSKonstantin Belousov uprintf("pid %d (%s): freebsd32_sigreturn eflags = 0x%x\n", 8465f82d16eSKonstantin Belousov td->td_proc->p_pid, td->td_name, eflags); 847d85631c4SPeter Wemm return (EINVAL); 848d85631c4SPeter Wemm } 849d85631c4SPeter Wemm 850d85631c4SPeter Wemm /* 851d85631c4SPeter Wemm * Don't allow users to load a valid privileged %cs. Let the 852d85631c4SPeter Wemm * hardware check for invalid selectors, excess privilege in 853d85631c4SPeter Wemm * other selectors, invalid %eip's and invalid %esp's. 854d85631c4SPeter Wemm */ 855d85631c4SPeter Wemm cs = ucp->uc_mcontext.mc_cs; 856d85631c4SPeter Wemm if (!CS_SECURE(cs)) { 8575f82d16eSKonstantin Belousov uprintf("pid %d (%s): sigreturn cs = 0x%x\n", 8585f82d16eSKonstantin Belousov td->td_proc->p_pid, td->td_name, cs); 8599104847fSDavid Xu ksiginfo_init_trap(&ksi); 8609104847fSDavid Xu ksi.ksi_signo = SIGBUS; 8619104847fSDavid Xu ksi.ksi_code = BUS_OBJERR; 8629104847fSDavid Xu ksi.ksi_trapno = T_PROTFLT; 8639104847fSDavid Xu ksi.ksi_addr = (void *)regs->tf_rip; 8649104847fSDavid Xu trapsignal(td, &ksi); 865d85631c4SPeter Wemm return (EINVAL); 866d85631c4SPeter Wemm } 867d85631c4SPeter Wemm 8688c6f8f3dSKonstantin Belousov if ((ucp->uc_mcontext.mc_flags & _MC_HASFPXSTATE) != 0) { 8698c6f8f3dSKonstantin Belousov xfpustate_len = uc.uc_mcontext.mc_xfpustate_len; 8708c6f8f3dSKonstantin Belousov if (xfpustate_len > cpu_max_ext_state_size - 8718c6f8f3dSKonstantin Belousov sizeof(struct savefpu)) { 8728c6f8f3dSKonstantin Belousov uprintf("pid %d (%s): sigreturn xfpusave_len = 0x%zx\n", 8738c6f8f3dSKonstantin Belousov td->td_proc->p_pid, td->td_name, xfpustate_len); 8748c6f8f3dSKonstantin Belousov return (EINVAL); 8758c6f8f3dSKonstantin Belousov } 876*bd9e0f5dSKonstantin Belousov xfpustate = (char *)fpu_save_area_alloc(); 8778c6f8f3dSKonstantin Belousov error = copyin(PTRIN(ucp->uc_mcontext.mc_xfpustate), 8788c6f8f3dSKonstantin Belousov xfpustate, xfpustate_len); 8798c6f8f3dSKonstantin Belousov if (error != 0) { 880*bd9e0f5dSKonstantin Belousov fpu_save_area_free((struct savefpu *)xfpustate); 8818c6f8f3dSKonstantin Belousov uprintf( 8828c6f8f3dSKonstantin Belousov "pid %d (%s): sigreturn copying xfpustate failed\n", 8838c6f8f3dSKonstantin Belousov td->td_proc->p_pid, td->td_name); 8848c6f8f3dSKonstantin Belousov return (error); 8858c6f8f3dSKonstantin Belousov } 8868c6f8f3dSKonstantin Belousov } else { 8878c6f8f3dSKonstantin Belousov xfpustate = NULL; 8888c6f8f3dSKonstantin Belousov xfpustate_len = 0; 8898c6f8f3dSKonstantin Belousov } 8908c6f8f3dSKonstantin Belousov ret = ia32_set_fpcontext(td, &ucp->uc_mcontext, xfpustate, 8918c6f8f3dSKonstantin Belousov xfpustate_len); 892*bd9e0f5dSKonstantin Belousov fpu_save_area_free((struct savefpu *)xfpustate); 8938c6f8f3dSKonstantin Belousov if (ret != 0) { 8948c6f8f3dSKonstantin Belousov uprintf("pid %d (%s): sigreturn set_fpcontext err %d\n", 8958c6f8f3dSKonstantin Belousov td->td_proc->p_pid, td->td_name, ret); 896d85631c4SPeter Wemm return (ret); 8978c6f8f3dSKonstantin Belousov } 898d85631c4SPeter Wemm 899d85631c4SPeter Wemm regs->tf_rdi = ucp->uc_mcontext.mc_edi; 900d85631c4SPeter Wemm regs->tf_rsi = ucp->uc_mcontext.mc_esi; 901d85631c4SPeter Wemm regs->tf_rbp = ucp->uc_mcontext.mc_ebp; 902d85631c4SPeter Wemm regs->tf_rbx = ucp->uc_mcontext.mc_ebx; 903d85631c4SPeter Wemm regs->tf_rdx = ucp->uc_mcontext.mc_edx; 904d85631c4SPeter Wemm regs->tf_rcx = ucp->uc_mcontext.mc_ecx; 905d85631c4SPeter Wemm regs->tf_rax = ucp->uc_mcontext.mc_eax; 906d85631c4SPeter Wemm regs->tf_trapno = ucp->uc_mcontext.mc_trapno; 907d85631c4SPeter Wemm regs->tf_err = ucp->uc_mcontext.mc_err; 908d85631c4SPeter Wemm regs->tf_rip = ucp->uc_mcontext.mc_eip; 909d85631c4SPeter Wemm regs->tf_cs = cs; 910d85631c4SPeter Wemm regs->tf_rflags = ucp->uc_mcontext.mc_eflags; 911d85631c4SPeter Wemm regs->tf_rsp = ucp->uc_mcontext.mc_esp; 912d85631c4SPeter Wemm regs->tf_ss = ucp->uc_mcontext.mc_ss; 9132c66cccaSKonstantin Belousov regs->tf_ds = ucp->uc_mcontext.mc_ds; 9142c66cccaSKonstantin Belousov regs->tf_es = ucp->uc_mcontext.mc_es; 9152c66cccaSKonstantin Belousov regs->tf_fs = ucp->uc_mcontext.mc_fs; 9162c66cccaSKonstantin Belousov regs->tf_gs = ucp->uc_mcontext.mc_gs; 9172c66cccaSKonstantin Belousov regs->tf_flags = TF_HASSEGS; 918d85631c4SPeter Wemm 919d6e029adSKonstantin Belousov kern_sigprocmask(td, SIG_SETMASK, &ucp->uc_sigmask, NULL, 0); 920e6c006d9SJung-uk Kim set_pcb_flags(td->td_pcb, PCB_FULL_IRET); 921d85631c4SPeter Wemm return (EJUSTRETURN); 922d85631c4SPeter Wemm } 9234cd2d525SPeter Wemm 9244cd2d525SPeter Wemm /* 9254cd2d525SPeter Wemm * Clear registers on exec 9264cd2d525SPeter Wemm */ 9274cd2d525SPeter Wemm void 92831174518SJohn Baldwin ia32_setregs(struct thread *td, struct image_params *imgp, uintptr_t stack) 9294cd2d525SPeter Wemm { 9307c5d1690SKonstantin Belousov struct trapframe *regs; 9317c5d1690SKonstantin Belousov struct pcb *pcb; 9327c5d1690SKonstantin Belousov register_t saved_rflags; 9337c5d1690SKonstantin Belousov 9347c5d1690SKonstantin Belousov regs = td->td_frame; 9357c5d1690SKonstantin Belousov pcb = td->td_pcb; 9364cd2d525SPeter Wemm 9372c66cccaSKonstantin Belousov if (td->td_proc->p_md.md_ldt != NULL) 9382c66cccaSKonstantin Belousov user_ldt_free(td); 9397332c129SKonstantin Belousov #ifdef COMPAT_43 9407332c129SKonstantin Belousov setup_lcall_gate(); 9417332c129SKonstantin Belousov #endif 9422c66cccaSKonstantin Belousov 9434cd2d525SPeter Wemm pcb->pcb_fsbase = 0; 9444cd2d525SPeter Wemm pcb->pcb_gsbase = 0; 9452ee8325fSJohn Baldwin pcb->pcb_initial_fpucw = __INITIAL_FPUCW_I386__; 9464cd2d525SPeter Wemm 9477c5d1690SKonstantin Belousov saved_rflags = regs->tf_rflags & PSL_T; 9484cd2d525SPeter Wemm bzero((char *)regs, sizeof(struct trapframe)); 949a107d8aaSNathan Whitehorn regs->tf_rip = imgp->entry_addr; 9504cd2d525SPeter Wemm regs->tf_rsp = stack; 9517c5d1690SKonstantin Belousov regs->tf_rflags = PSL_USER | saved_rflags; 9524cd2d525SPeter Wemm regs->tf_ss = _udatasel; 9534cd2d525SPeter Wemm regs->tf_cs = _ucode32sel; 954397df744SBrooks Davis regs->tf_rbx = (register_t)imgp->ps_strings; 9552c66cccaSKonstantin Belousov regs->tf_ds = _udatasel; 9562c66cccaSKonstantin Belousov regs->tf_es = _udatasel; 9572c66cccaSKonstantin Belousov regs->tf_fs = _ufssel; 9582c66cccaSKonstantin Belousov regs->tf_gs = _ugssel; 9592c66cccaSKonstantin Belousov regs->tf_flags = TF_HASSEGS; 9602c66cccaSKonstantin Belousov 961d50adfecSKonstantin Belousov x86_clear_dbregs(pcb); 962d50adfecSKonstantin Belousov 9634cd2d525SPeter Wemm fpstate_drop(td); 9644cd2d525SPeter Wemm 9654cd2d525SPeter Wemm /* Return via doreti so that we can change to a different %cs */ 966e6c006d9SJung-uk Kim set_pcb_flags(pcb, PCB_32BIT | PCB_FULL_IRET); 9674cd2d525SPeter Wemm } 968