/* $NetBSD: linux_machdep.c,v 1.19 2002/09/25 22:21:35 thorpej Exp $ */ /*- * Copyright (c) 1995, 2000, 2001 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Frank van der Linden and Emmanuel Dreyfus. * * 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 the NetBSD * Foundation, Inc. and its contributors. * 4. Neither the name of The NetBSD Foundation nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.19 2002/09/25 22:21:35 thorpej Exp $"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #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 "wsdisplay.h" #endif #if (NWSDISPLAY > 0) #include #include #endif /* * Set set up registers on exec. * XXX not used at the moment since in sys/kern/exec_conf, LINUX_COMPAT * entry uses NetBSD's native setregs instead of linux_setregs */ void linux_setregs(p, pack, stack) struct proc *p; struct exec_package *pack; u_long stack; { setregs(p, pack, stack); } /* * Send an interrupt to process. * * Adapted from arch/powerpc/powerpc/sig_machdep.c:sendsig and * compat/linux/arch/i386/linux_machdep.c:linux_sendsig * * XXX Does not work well yet with RT signals * */ void linux_sendsig(sig, mask, code) /* XXX Check me */ int sig; sigset_t *mask; u_long code; { struct proc *p = curproc; struct trapframe *tf; sig_t catcher = SIGACTION(p, sig).sa_handler; struct linux_sigregs frame; struct linux_pt_regs linux_regs; struct linux_sigcontext sc; register_t fp; int onstack; int i; tf = trapframe(p); /* * Do we need to jump onto the signal stack? */ onstack = (p->p_sigctx.ps_sigstk.ss_flags & (SS_DISABLE | SS_ONSTACK)) == 0 && (SIGACTION(p, sig).sa_flags & SA_ONSTACK) != 0; /* * Signal stack is broken (see at the end of linux_sigreturn), so we do * not use it yet. XXX fix this. */ onstack=0; /* * Allocate space for the signal handler context. */ if (onstack) { fp = (register_t) ((caddr_t)p->p_sigctx.ps_sigstk.ss_sp + p->p_sigctx.ps_sigstk.ss_size); } else { fp = tf->fixreg[1]; } #ifdef DEBUG_LINUX printf("fp at start of linux_sendsig = %x\n", fp); #endif fp -= sizeof(struct linux_sigregs); fp &= ~0xf; /* * Prepare a sigcontext for later. */ memset(&sc, 0, sizeof sc); sc.lsignal = (int)native_to_linux_signo[sig]; sc.lhandler = (unsigned long)catcher; native_to_linux_old_extra_sigset(&sc.lmask, &sc._unused[3], mask); sc.lregs = (struct linux_pt_regs*)fp; /* * Setup the signal stack frame as Linux does it in * arch/ppc/kernel/signal.c:setup_frame() * * Save register context. */ for (i = 0; i < 32; i++) linux_regs.lgpr[i] = tf->fixreg[i]; linux_regs.lnip = tf->srr0; linux_regs.lmsr = tf->srr1; linux_regs.lorig_gpr3 = tf->fixreg[3]; /* XXX Is that right? */ linux_regs.lctr = tf->ctr; linux_regs.llink = tf->lr; linux_regs.lxer = tf->xer; linux_regs.lccr = tf->cr; linux_regs.lmq = 0; /* Unused, 601 only */ linux_regs.ltrap = tf->exc; linux_regs.ldar = tf->dar; linux_regs.ldsisr = tf->dsisr; linux_regs.lresult = 0; memset(&frame, 0, sizeof(frame)); memcpy(&frame.lgp_regs, &linux_regs, sizeof(linux_regs)); save_fpu_proc(curproc); memcpy(&frame.lfp_regs, curpcb->pcb_fpu.fpr, sizeof(frame.lfp_regs)); /* * Copy Linux's signal trampoline on the user stack It should not * be used, but Linux binaries might expect it to be there. */ frame.ltramp[0] = 0x38997777; /* li r0, 0x7777 */ frame.ltramp[1] = 0x44000002; /* sc */ /* * Move it to the user stack * There is a little trick here, about the LINUX_ABIGAP: the * linux_sigreg structure has a 56 int gap to support rs6000/xcoff * binaries. But the Linux kernel seems to do without it, and it * just skip it when building the stack frame. Hence the LINUX_ABIGAP. */ if (copyout(&frame, (caddr_t)fp, sizeof (frame) - LINUX_ABIGAP) != 0) { /* * Process has trashed its stack; give it an illegal * instruction to halt it in its tracks. */ sigexit(p, SIGILL); /* NOTREACHED */ } /* * Add a sigcontext on the stack */ fp -= sizeof(struct linux_sigcontext); if (copyout(&sc, (caddr_t)fp, sizeof (struct linux_sigcontext)) != 0) { /* * Process has trashed its stack; give it an illegal * instruction to halt it in its tracks. */ sigexit(p, SIGILL); /* NOTREACHED */ } /* * Set the registers according to how the Linux process expects them. * "Mind the gap" Linux expects a gap here. */ tf->fixreg[1] = fp - LINUX__SIGNAL_FRAMESIZE; tf->lr = (int)catcher; tf->fixreg[3] = (int)native_to_linux_signo[sig]; tf->fixreg[4] = fp; tf->srr0 = (int)p->p_sigctx.ps_sigcode; #ifdef DEBUG_LINUX printf("fp at end of linux_sendsig = %x\n", fp); #endif /* * Remember that we're now on the signal stack. */ if (onstack) p->p_sigctx.ps_sigstk.ss_flags |= SS_ONSTACK; #ifdef DEBUG_LINUX printf("linux_sendsig: exitting. fp=0x%lx\n",(long)fp); #endif } /* * System call to cleanup state after a signal * has been taken. Reset signal mask and * stack state from context left by sendsig (above). * Return to previous pc and psl as specified by * context left by sendsig. Check carefully to * make sure that the user has not modified the * psl to gain improper privileges or to cause * a machine fault. * * XXX not tested */ int linux_sys_rt_sigreturn(p, v, retval) struct proc *p; void *v; register_t *retval; { struct linux_sys_rt_sigreturn_args /* { syscallarg(struct linux_rt_sigframe *) sfp; } */ *uap = v; struct linux_rt_sigframe *scp, sigframe; struct linux_sigregs sregs; struct linux_pt_regs *lregs; struct trapframe *tf; sigset_t mask; int i; /* * The trampoline code hands us the context. * It is unsafe to keep track of it ourselves, in the event that a * program jumps out of a signal handler. */ scp = SCARG(uap, sfp); /* * Get the context from user stack */ if (copyin((caddr_t)scp, &sigframe, sizeof(*scp))) return (EFAULT); /* * Make sure, fpu is sync'ed */ save_fpu_proc(curproc); /* * Restore register context. */ if (copyin((caddr_t)sigframe.luc.luc_context.lregs, &sregs, sizeof(sregs))) return (EFAULT); lregs = (struct linux_pt_regs *)&sregs.lgp_regs; tf = trapframe(p); #ifdef DEBUG_LINUX printf("linux_sys_sigreturn: trapframe=0x%lx scp=0x%lx\n", (unsigned long)tf, (unsigned long)scp); #endif if ((lregs->lmsr & PSL_USERSTATIC) != (tf->srr1 & PSL_USERSTATIC)) return (EINVAL); for (i = 0; i < 32; i++) tf->fixreg[i] = lregs->lgpr[i]; tf->lr = lregs->llink; tf->cr = lregs->lccr; tf->xer = lregs->lxer; tf->ctr = lregs->lctr; tf->srr0 = lregs->lnip; tf->srr1 = lregs->lmsr; memcpy(curpcb->pcb_fpu.fpr, (caddr_t)&sregs.lfp_regs, sizeof(curpcb->pcb_fpu.fpr)); /* * Restore signal stack. * * XXX cannot find the onstack information in Linux sig context. * Is signal stack really supported on Linux? * * It seems to be supported in libc6... */ /* if (sc.sc_onstack & SS_ONSTACK) p->p_sigctx.ps_sigstk.ss_flags |= SS_ONSTACK; else */ p->p_sigctx.ps_sigstk.ss_flags &= ~SS_ONSTACK; /* * Grab the signal mask */ linux_to_native_sigset(&mask, &sigframe.luc.luc_sigmask); (void) sigprocmask1(p, SIG_SETMASK, &mask, 0); return (EJUSTRETURN); } /* * The following needs code review for potential security issues */ int linux_sys_sigreturn(p, v, retval) struct proc *p; void *v; register_t *retval; { struct linux_sys_sigreturn_args /* { syscallarg(struct linux_sigcontext *) scp; } */ *uap = v; struct linux_sigcontext *scp, context; struct linux_sigregs sregs; struct linux_pt_regs *lregs; struct trapframe *tf; sigset_t mask; int i; /* * The trampoline code hands us the context. * It is unsafe to keep track of it ourselves, in the event that a * program jumps out of a signal handler. */ scp = SCARG(uap, scp); /* * Get the context from user stack */ if (copyin(scp, &context, sizeof(*scp))) return (EFAULT); /* * Make sure, fpu is in sync */ save_fpu_proc(curproc); /* * Restore register context. */ if (copyin((caddr_t)context.lregs, &sregs, sizeof(sregs))) return (EFAULT); lregs = (struct linux_pt_regs *)&sregs.lgp_regs; tf = trapframe(p); #ifdef DEBUG_LINUX printf("linux_sys_sigreturn: trapframe=0x%lx scp=0x%lx\n", (unsigned long)tf, (unsigned long)scp); #endif if ((lregs->lmsr & PSL_USERSTATIC) != (tf->srr1 & PSL_USERSTATIC)) return (EINVAL); for (i = 0; i < 32; i++) tf->fixreg[i] = lregs->lgpr[i]; tf->lr = lregs->llink; tf->cr = lregs->lccr; tf->xer = lregs->lxer; tf->ctr = lregs->lctr; tf->srr0 = lregs->lnip; tf->srr1 = lregs->lmsr; memcpy(curpcb->pcb_fpu.fpr, (caddr_t)&sregs.lfp_regs, sizeof(curpcb->pcb_fpu.fpr)); /* * Restore signal stack. * * XXX cannot find the onstack information in Linux sig context. * Is signal stack really supported on Linux? */ #if 0 if (sc.sc_onstack & SS_ONSTACK) p->p_sigctx.ps_sigstk.ss_flags |= SS_ONSTACK; else #endif p->p_sigctx.ps_sigstk.ss_flags &= ~SS_ONSTACK; /* Restore signal mask. */ linux_old_extra_to_native_sigset(&mask, &context.lmask, &context._unused[3]); (void) sigprocmask1(p, SIG_SETMASK, &mask, 0); return (EJUSTRETURN); } #if 0 int linux_sys_modify_ldt(p, v, retval) struct proc *p; void *v; register_t *retval; { /* * This syscall is not implemented in Linux/PowerPC: we should not * be here */ #ifdef DEBUG_LINUX printf("linux_sys_modify_ldt: should not be here.\n"); #endif return 0; } #endif /* * major device numbers remapping */ dev_t linux_fakedev(dev, raw) dev_t dev; int raw; { /* XXX write me */ return dev; } /* * We come here in a last attempt to satisfy a Linux ioctl() call */ int linux_machdepioctl(p, v, retval) struct proc *p; void *v; register_t *retval; { struct linux_sys_ioctl_args /* { syscallarg(int) fd; syscallarg(u_long) com; syscallarg(caddr_t) data; } */ *uap = v; struct sys_ioctl_args bia; u_long com; SCARG(&bia, fd) = SCARG(uap, fd); SCARG(&bia, data) = SCARG(uap, data); com = SCARG(uap, com); switch (com) { default: printf("linux_machdepioctl: invalid ioctl %08lx\n", com); return EINVAL; } SCARG(&bia, com) = com; return sys_ioctl(p, &bia, retval); } #if 0 /* * Set I/O permissions for a process. Just set the maximum level * right away (ignoring the argument), otherwise we would have * to rely on I/O permission maps, which are not implemented. */ int linux_sys_iopl(p, v, retval) struct proc *p; void *v; register_t *retval; { /* * This syscall is not implemented in Linux/PowerPC: we should not be here */ #ifdef DEBUG_LINUX printf("linux_sys_iopl: should not be here.\n"); #endif return 0; } #endif /* * See above. If a root process tries to set access to an I/O port, * just let it have the whole range. */ int linux_sys_ioperm(p, v, retval) struct proc *p; void *v; register_t *retval; { /* * This syscall is not implemented in Linux/PowerPC: we should not be here */ #ifdef DEBUG_LINUX printf("linux_sys_ioperm: should not be here.\n"); #endif return 0; } /* * wrapper linux_sys_new_uname() -> linux_sys_uname() */ int linux_sys_new_uname(p, v, retval) struct proc *p; void *v; register_t *retval; { return linux_sys_uname(p, v, retval); } /* * wrapper linux_sys_new_select() -> linux_sys_select() */ int linux_sys_new_select(p, v, retval) struct proc *p; void *v; register_t *retval; { return linux_sys_select(p, v, retval); }