/* $NetBSD: linux_machdep.c,v 1.58.2.2 2022/08/03 11:11:33 martin Exp $ */ /*- * Copyright (c) 2005 Emmanuel Dreyfus, all rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Emmanuel Dreyfus * 4. The name of the author may not be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE THE AUTHOR AND CONTRIBUTORS ``AS IS'' * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include __KERNEL_RCSID(0, "$NetBSD: linux_machdep.c,v 1.58.2.2 2022/08/03 11:11:33 martin Exp $"); #include #include #include #include #include #include #include /* for process_read_fpregs() */ #include #include #include #include #include #include #include #include #include /* * To see whether wscons is configured (for virtual console ioctl calls). */ #if defined(_KERNEL_OPT) #include "opt_user_ldt.h" #include "wsdisplay.h" #endif #if (NWSDISPLAY > 0) #include #include #endif #include #include #include #include #include #include #include #include #include #include static void linux_buildcontext(struct lwp *, void *, void *); void linux_setregs(struct lwp *l, struct exec_package *epp, vaddr_t stack) { struct pcb *pcb = lwp_getpcb(l); struct trapframe *tf; #ifdef USER_LDT pmap_ldt_cleanup(l); #endif fpu_clear(l, __NetBSD_NPXCW__); kpreempt_disable(); pcb->pcb_flags = 0; l->l_proc->p_flag &= ~PK_32; l->l_md.md_flags = MDL_IRET; cpu_segregs64_zero(l); kpreempt_enable(); tf = l->l_md.md_regs; tf->tf_rax = 0; tf->tf_rbx = 0; tf->tf_rcx = epp->ep_entry; tf->tf_rdx = 0; tf->tf_rsi = 0; tf->tf_rdi = 0; tf->tf_rbp = 0; tf->tf_rsp = stack; tf->tf_r8 = 0; tf->tf_r9 = 0; tf->tf_r10 = 0; tf->tf_r11 = 0; tf->tf_r12 = 0; tf->tf_r13 = 0; tf->tf_r14 = 0; tf->tf_r15 = 0; tf->tf_rip = epp->ep_entry; tf->tf_rflags = PSL_USERSET; tf->tf_cs = GSEL(GUCODE_SEL, SEL_UPL); tf->tf_ss = GSEL(GUDATA_SEL, SEL_UPL); tf->tf_ds = GSEL(GUDATA_SEL, SEL_UPL); tf->tf_es = 0; return; } void linux_sendsig(const ksiginfo_t *ksi, const sigset_t *mask) { struct lwp *l = curlwp; struct proc *p = l->l_proc; struct pcb *pcb = lwp_getpcb(l); struct sigacts *ps = p->p_sigacts; int onstack, error; int sig = ksi->ksi_signo; struct linux_rt_sigframe *sfp, sigframe; struct linux__fpstate *fpsp; struct fpreg fpregs; struct trapframe *tf = l->l_md.md_regs; sig_t catcher = SIGACTION(p, sig).sa_handler; linux_sigset_t lmask; char *sp; /* Do we need to jump onto the signal stack? */ onstack = (l->l_sigstk.ss_flags & (SS_DISABLE | SS_ONSTACK)) == 0 && (SIGACTION(p, sig).sa_flags & SA_ONSTACK) != 0; /* Allocate space for the signal handler context. */ if (onstack) sp = ((char *)l->l_sigstk.ss_sp + l->l_sigstk.ss_size); else sp = (char *)tf->tf_rsp - 128; /* Save FPU state */ sp = (char *) (((long)sp - sizeof (*fpsp)) & ~0xfUL); fpsp = (struct linux__fpstate *)sp; /* * Populate the rt_sigframe */ sp = (char *) ((((long)sp - sizeof(struct linux_rt_sigframe)) & ~0xfUL) - 8); sfp = (struct linux_rt_sigframe *)sp; memset(&sigframe, 0, sizeof(sigframe)); if (ps->sa_sigdesc[sig].sd_vers != 0) sigframe.pretcode = (char *)(u_long)ps->sa_sigdesc[sig].sd_tramp; else sigframe.pretcode = NULL; /* * The user context */ sigframe.uc.luc_flags = 0; sigframe.uc.luc_link = NULL; /* This is used regardless of SA_ONSTACK in Linux */ sigframe.uc.luc_stack.ss_sp = l->l_sigstk.ss_sp; sigframe.uc.luc_stack.ss_size = l->l_sigstk.ss_size; sigframe.uc.luc_stack.ss_flags = 0; if (l->l_sigstk.ss_flags & SS_ONSTACK) sigframe.uc.luc_stack.ss_flags |= LINUX_SS_ONSTACK; if (l->l_sigstk.ss_flags & SS_DISABLE) sigframe.uc.luc_stack.ss_flags |= LINUX_SS_DISABLE; sigframe.uc.luc_mcontext.r8 = tf->tf_r8; sigframe.uc.luc_mcontext.r9 = tf->tf_r9; sigframe.uc.luc_mcontext.r10 = tf->tf_r10; sigframe.uc.luc_mcontext.r11 = tf->tf_r11; sigframe.uc.luc_mcontext.r12 = tf->tf_r12; sigframe.uc.luc_mcontext.r13 = tf->tf_r13; sigframe.uc.luc_mcontext.r14 = tf->tf_r14; sigframe.uc.luc_mcontext.r15 = tf->tf_r15; sigframe.uc.luc_mcontext.rdi = tf->tf_rdi; sigframe.uc.luc_mcontext.rsi = tf->tf_rsi; sigframe.uc.luc_mcontext.rbp = tf->tf_rbp; sigframe.uc.luc_mcontext.rbx = tf->tf_rbx; sigframe.uc.luc_mcontext.rdx = tf->tf_rdx; sigframe.uc.luc_mcontext.rax = tf->tf_rax; sigframe.uc.luc_mcontext.rcx = tf->tf_rcx; sigframe.uc.luc_mcontext.rsp = tf->tf_rsp; sigframe.uc.luc_mcontext.rip = tf->tf_rip; sigframe.uc.luc_mcontext.eflags = tf->tf_rflags; sigframe.uc.luc_mcontext.cs = GSEL(GUCODE_SEL, SEL_UPL); sigframe.uc.luc_mcontext.gs = tf->tf_gs & 0xFFFF; sigframe.uc.luc_mcontext.fs = tf->tf_fs & 0xFFFF; sigframe.uc.luc_mcontext.err = tf->tf_err; sigframe.uc.luc_mcontext.trapno = tf->tf_trapno; native_to_linux_sigset(&lmask, mask); sigframe.uc.luc_mcontext.oldmask = lmask.sig[0]; sigframe.uc.luc_mcontext.cr2 = (long)pcb->pcb_onfault; sigframe.uc.luc_mcontext.fpstate = fpsp; native_to_linux_sigset(&sigframe.uc.luc_sigmask, mask); native_to_linux_siginfo(&sigframe.info, &ksi->ksi_info); sendsig_reset(l, sig); mutex_exit(p->p_lock); error = 0; /* * Save FPU state, if any */ if (fpsp != NULL) { size_t fp_size = sizeof fpregs; /* The netbsd and linux structures both match the fxsave data */ memset(&fpregs, 0, sizeof(fpregs)); (void)process_read_fpregs(l, &fpregs, &fp_size); error = copyout(&fpregs, fpsp, sizeof(*fpsp)); } if (error == 0) error = copyout(&sigframe, sp, sizeof(sigframe)); mutex_enter(p->p_lock); if (error != 0) { sigexit(l, SIGILL); return; } if ((vaddr_t)catcher >= VM_MAXUSER_ADDRESS) { sigexit(l, SIGILL); return; } linux_buildcontext(l, catcher, sp); tf->tf_rdi = sigframe.info.lsi_signo; tf->tf_rax = 0; tf->tf_rsi = (long)&sfp->info; tf->tf_rdx = (long)&sfp->uc; /* * Remember we use signal stack */ if (onstack) l->l_sigstk.ss_flags |= SS_ONSTACK; return; } int linux_sys_modify_ldt(struct lwp *l, const struct linux_sys_modify_ldt_args *v, register_t *retval) { return 0; } int linux_sys_iopl(struct lwp *l, const struct linux_sys_iopl_args *v, register_t *retval) { return 0; } int linux_sys_ioperm(struct lwp *l, const struct linux_sys_ioperm_args *v, register_t *retval) { return 0; } dev_t linux_fakedev(dev_t dev, int raw) { extern const struct cdevsw ptc_cdevsw, pts_cdevsw; const struct cdevsw *cd = cdevsw_lookup(dev); if (raw) { #if (NWSDISPLAY > 0) extern const struct cdevsw wsdisplay_cdevsw; if (cd == &wsdisplay_cdevsw) return makedev(LINUX_CONS_MAJOR, (minor(dev) + 1)); #endif } if (cd == &ptc_cdevsw) return makedev(LINUX_PTC_MAJOR, minor(dev)); if (cd == &pts_cdevsw) return makedev(LINUX_PTS_MAJOR, minor(dev)); return ((minor(dev) & 0xff) | ((major(dev) & 0xfff) << 8) | (((unsigned long long int) (minor(dev) & ~0xff)) << 12) | (((unsigned long long int) (major(dev) & ~0xfff)) << 32)); } int linux_machdepioctl(struct lwp *l, const struct linux_sys_ioctl_args *v, register_t *retval) { return 0; } int linux_sys_rt_sigreturn(struct lwp *l, const void *v, register_t *retval) { struct linux_ucontext *luctx; struct trapframe *tf = l->l_md.md_regs; struct linux_sigcontext *lsigctx; struct linux_rt_sigframe frame, *fp; ucontext_t uctx; mcontext_t *mctx; struct fxsave *fxarea; int error; fp = (struct linux_rt_sigframe *)(tf->tf_rsp - 8); if ((error = copyin(fp, &frame, sizeof(frame))) != 0) { mutex_enter(l->l_proc->p_lock); sigexit(l, SIGILL); return error; } luctx = &frame.uc; lsigctx = &luctx->luc_mcontext; memset(&uctx, 0, sizeof(uctx)); mctx = (mcontext_t *)&uctx.uc_mcontext; fxarea = (struct fxsave *)&mctx->__fpregs; /* * Set the flags. Linux always have CPU, stack and signal state, * FPU is optional. uc_flags is not used to tell what we have. */ uctx.uc_flags = (_UC_SIGMASK|_UC_CPU|_UC_STACK|_UC_CLRSTACK); if (lsigctx->fpstate != NULL) uctx.uc_flags |= _UC_FPU; uctx.uc_link = NULL; /* * Signal set */ linux_to_native_sigset(&uctx.uc_sigmask, &luctx->luc_sigmask); /* * CPU state */ mctx->__gregs[_REG_R8] = lsigctx->r8; mctx->__gregs[_REG_R9] = lsigctx->r9; mctx->__gregs[_REG_R10] = lsigctx->r10; mctx->__gregs[_REG_R11] = lsigctx->r11; mctx->__gregs[_REG_R12] = lsigctx->r12; mctx->__gregs[_REG_R13] = lsigctx->r13; mctx->__gregs[_REG_R14] = lsigctx->r14; mctx->__gregs[_REG_R15] = lsigctx->r15; mctx->__gregs[_REG_RDI] = lsigctx->rdi; mctx->__gregs[_REG_RSI] = lsigctx->rsi; mctx->__gregs[_REG_RBP] = lsigctx->rbp; mctx->__gregs[_REG_RBX] = lsigctx->rbx; mctx->__gregs[_REG_RAX] = lsigctx->rax; mctx->__gregs[_REG_RDX] = lsigctx->rdx; mctx->__gregs[_REG_RCX] = lsigctx->rcx; mctx->__gregs[_REG_RIP] = lsigctx->rip; mctx->__gregs[_REG_RFLAGS] = lsigctx->eflags; mctx->__gregs[_REG_CS] = lsigctx->cs & 0xFFFF; mctx->__gregs[_REG_GS] = lsigctx->gs & 0xFFFF; mctx->__gregs[_REG_FS] = lsigctx->fs & 0xFFFF; mctx->__gregs[_REG_ERR] = lsigctx->err; mctx->__gregs[_REG_TRAPNO] = lsigctx->trapno; mctx->__gregs[_REG_ES] = tf->tf_es & 0xFFFF; mctx->__gregs[_REG_DS] = tf->tf_ds & 0xFFFF; mctx->__gregs[_REG_RSP] = lsigctx->rsp; /* XXX */ mctx->__gregs[_REG_SS] = tf->tf_ss & 0xFFFF; /* * FPU state */ if (lsigctx->fpstate != NULL) { /* Both structures match the fxstate data */ error = copyin(lsigctx->fpstate, fxarea, sizeof(*fxarea)); if (error != 0) { mutex_enter(l->l_proc->p_lock); sigexit(l, SIGILL); return error; } } /* * And the stack */ uctx.uc_stack.ss_flags = 0; if (luctx->luc_stack.ss_flags & LINUX_SS_ONSTACK) uctx.uc_stack.ss_flags |= SS_ONSTACK; if (luctx->luc_stack.ss_flags & LINUX_SS_DISABLE) uctx.uc_stack.ss_flags |= SS_DISABLE; uctx.uc_stack.ss_sp = luctx->luc_stack.ss_sp; uctx.uc_stack.ss_size = luctx->luc_stack.ss_size; /* * And let setucontext deal with that. */ mutex_enter(l->l_proc->p_lock); error = setucontext(l, &uctx); mutex_exit(l->l_proc->p_lock); if (error) return error; return EJUSTRETURN; } int linux_sys_arch_prctl(struct lwp *l, const struct linux_sys_arch_prctl_args *uap, register_t *retval) { /* { syscallarg(int) code; syscallarg(unsigned long) addr; } */ void *addr = (void *)SCARG(uap, addr); switch(SCARG(uap, code)) { case LINUX_ARCH_SET_GS: return x86_set_sdbase(addr, 'g', l, true); case LINUX_ARCH_GET_GS: return x86_get_sdbase(addr, 'g'); case LINUX_ARCH_SET_FS: return x86_set_sdbase(addr, 'f', l, true); case LINUX_ARCH_GET_FS: return x86_get_sdbase(addr, 'f'); default: #ifdef DEBUG_LINUX printf("linux_sys_arch_prctl: unexpected code %d\n", SCARG(uap, code)); #endif return EINVAL; } /* NOTREACHED */ } const int linux_vsyscall_to_syscall[] = { LINUX_SYS_gettimeofday, LINUX_SYS_time, LINUX_SYS_nosys, /* nosys */ LINUX_SYS_nosys, /* nosys */ }; int linux_usertrap(struct lwp *l, vaddr_t trapaddr, void *arg) { struct trapframe *tf = arg; uint64_t retaddr; size_t vsyscallnr; /* * Check for a vsyscall. %rip must be the fault address, * and the address must be in the Linux vsyscall area. * Also, vsyscalls are only done at 1024-byte boundaries. */ if (__predict_true(trapaddr < LINUX_VSYSCALL_START)) return 0; if (trapaddr != tf->tf_rip) return 0; if ((tf->tf_rip & (LINUX_VSYSCALL_SIZE - 1)) != 0) return 0; vsyscallnr = (tf->tf_rip - LINUX_VSYSCALL_START) / LINUX_VSYSCALL_SIZE; if (vsyscallnr > LINUX_VSYSCALL_MAXNR) return 0; /* * Get the return address from the top of the stack, * and fix up the return address. * This assumes the faulting instruction was callq *reg, * which is the only way that vsyscalls are ever entered. */ if (copyin((void *)tf->tf_rsp, &retaddr, sizeof retaddr) != 0) return 0; if ((vaddr_t)retaddr >= VM_MAXUSER_ADDRESS) return 0; tf->tf_rip = retaddr; tf->tf_rax = linux_vsyscall_to_syscall[vsyscallnr]; tf->tf_rsp += 8; /* "pop" the return address */ #if 0 printf("usertrap: rip %p rsp %p retaddr %p vsys %d sys %d\n", (void *)tf->tf_rip, (void *)tf->tf_rsp, (void *)retaddr, vsyscallnr, (int)tf->tf_rax); #endif (*l->l_proc->p_md.md_syscall)(tf); return 1; } static void linux_buildcontext(struct lwp *l, void *catcher, void *f) { struct trapframe *tf = l->l_md.md_regs; tf->tf_ds = GSEL(GUDATA_SEL, SEL_UPL); tf->tf_rip = (u_int64_t)catcher; tf->tf_cs = GSEL(GUCODE_SEL, SEL_UPL); tf->tf_rflags &= ~PSL_CLEARSIG; tf->tf_rsp = (u_int64_t)f; tf->tf_ss = GSEL(GUDATA_SEL, SEL_UPL); }