/* Signal support for 32-bit kernel builds * * Copyright (C) 2001 Matthew Wilcox * Copyright (C) 2006 Kyle McMartin * * Code was mostly borrowed from kernel/signal.c. * See kernel/signal.c for additional Copyrights. * * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include #include #include #include #include "signal32.h" #include "sys32.h" #define DEBUG_COMPAT_SIG 0 #define DEBUG_COMPAT_SIG_LEVEL 2 #if DEBUG_COMPAT_SIG #define DBG(LEVEL, ...) \ ((DEBUG_COMPAT_SIG_LEVEL >= LEVEL) \ ? printk(__VA_ARGS__) : (void) 0) #else #define DBG(LEVEL, ...) #endif inline void sigset_32to64(sigset_t *s64, compat_sigset_t *s32) { s64->sig[0] = s32->sig[0] | ((unsigned long)s32->sig[1] << 32); } inline void sigset_64to32(compat_sigset_t *s32, sigset_t *s64) { s32->sig[0] = s64->sig[0] & 0xffffffffUL; s32->sig[1] = (s64->sig[0] >> 32) & 0xffffffffUL; } static int put_sigset32(compat_sigset_t __user *up, sigset_t *set, size_t sz) { compat_sigset_t s; if (sz != sizeof(compat_sigset_t)) return -EINVAL; sigset_64to32(&s, set); return copy_to_user(up, &s, sizeof s); } static int get_sigset32(compat_sigset_t __user *up, sigset_t *set, size_t sz) { compat_sigset_t s; int r; if (sz != sizeof(compat_sigset_t)) return -EINVAL; if ((r = copy_from_user(&s, up, sz)) == 0) { sigset_32to64(set, &s); } return r; } int sys32_rt_sigprocmask(int how, compat_sigset_t __user *set, compat_sigset_t __user *oset, unsigned int sigsetsize) { sigset_t old_set, new_set; int ret; if (set) { ret = get_sigset32(set, &new_set, sigsetsize); if (ret) return ret; } KERNEL_SYSCALL(ret, sys_rt_sigprocmask, how, set ? (sigset_t __user *)&new_set : NULL, oset ? (sigset_t __user *)&old_set : NULL, sigsetsize); if (!ret && oset && put_sigset32(oset, &old_set, sigsetsize)) return -EFAULT; return ret; } int sys32_rt_sigpending(compat_sigset_t __user *uset, unsigned int sigsetsize) { int ret; sigset_t set; KERNEL_SYSCALL(ret, sys_rt_sigpending, (sigset_t __user *)&set, sigsetsize); if (!ret && put_sigset32(uset, &set, sigsetsize)) return -EFAULT; return ret; } long sys32_rt_sigaction(int sig, const struct sigaction32 __user *act, struct sigaction32 __user *oact, size_t sigsetsize) { struct k_sigaction32 new_sa32, old_sa32; struct k_sigaction new_sa, old_sa; int ret = -EINVAL; /* XXX: Don't preclude handling different sized sigset_t's. */ if (sigsetsize != sizeof(compat_sigset_t)) return -EINVAL; if (act) { if (copy_from_user(&new_sa32.sa, act, sizeof new_sa32.sa)) return -EFAULT; new_sa.sa.sa_handler = (__sighandler_t)(unsigned long)new_sa32.sa.sa_handler; new_sa.sa.sa_flags = new_sa32.sa.sa_flags; sigset_32to64(&new_sa.sa.sa_mask, &new_sa32.sa.sa_mask); } ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL); if (!ret && oact) { sigset_64to32(&old_sa32.sa.sa_mask, &old_sa.sa.sa_mask); old_sa32.sa.sa_flags = old_sa.sa.sa_flags; old_sa32.sa.sa_handler = (__sighandler_t32)(unsigned long)old_sa.sa.sa_handler; if (copy_to_user(oact, &old_sa32.sa, sizeof old_sa32.sa)) return -EFAULT; } return ret; } int do_sigaltstack32 (const compat_stack_t __user *uss32, compat_stack_t __user *uoss32, unsigned long sp) { compat_stack_t ss32, oss32; stack_t ss, oss; stack_t *ssp = NULL, *ossp = NULL; int ret; if (uss32) { if (copy_from_user(&ss32, uss32, sizeof ss32)) return -EFAULT; ss.ss_sp = (void __user *)(unsigned long)ss32.ss_sp; ss.ss_flags = ss32.ss_flags; ss.ss_size = ss32.ss_size; ssp = &ss; } if (uoss32) ossp = &oss; KERNEL_SYSCALL(ret, do_sigaltstack, (const stack_t __user *)ssp, (stack_t __user *)ossp, sp); if (!ret && uoss32) { oss32.ss_sp = (unsigned int)(unsigned long)oss.ss_sp; oss32.ss_flags = oss.ss_flags; oss32.ss_size = oss.ss_size; if (copy_to_user(uoss32, &oss32, sizeof *uoss32)) return -EFAULT; } return ret; } long restore_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf, struct pt_regs *regs) { long err = 0; compat_uint_t compat_reg; compat_uint_t compat_regt; int regn; /* When loading 32-bit values into 64-bit registers make sure to clear the upper 32-bits */ DBG(2,"restore_sigcontext32: PER_LINUX32 process\n"); DBG(2,"restore_sigcontext32: sc = 0x%p, rf = 0x%p, regs = 0x%p\n", sc, rf, regs); DBG(2,"restore_sigcontext32: compat_sigcontext is %#lx bytes\n", sizeof(*sc)); for(regn=0; regn < 32; regn++){ err |= __get_user(compat_reg,&sc->sc_gr[regn]); regs->gr[regn] = compat_reg; /* Load upper half */ err |= __get_user(compat_regt,&rf->rf_gr[regn]); regs->gr[regn] = ((u64)compat_regt << 32) | (u64)compat_reg; DBG(3,"restore_sigcontext32: gr%02d = %#lx (%#x / %#x)\n", regn, regs->gr[regn], compat_regt, compat_reg); } DBG(2,"restore_sigcontext32: sc->sc_fr = 0x%p (%#lx)\n",sc->sc_fr, sizeof(sc->sc_fr)); /* XXX: BE WARNED FR's are 64-BIT! */ err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr)); /* Better safe than sorry, pass __get_user two things of the same size and let gcc do the upward conversion to 64-bits */ err |= __get_user(compat_reg, &sc->sc_iaoq[0]); /* Load upper half */ err |= __get_user(compat_regt, &rf->rf_iaoq[0]); regs->iaoq[0] = ((u64)compat_regt << 32) | (u64)compat_reg; DBG(2,"restore_sigcontext32: upper half of iaoq[0] = %#lx\n", compat_regt); DBG(2,"restore_sigcontext32: sc->sc_iaoq[0] = %p => %#x\n", &sc->sc_iaoq[0], compat_reg); err |= __get_user(compat_reg, &sc->sc_iaoq[1]); /* Load upper half */ err |= __get_user(compat_regt, &rf->rf_iaoq[1]); regs->iaoq[1] = ((u64)compat_regt << 32) | (u64)compat_reg; DBG(2,"restore_sigcontext32: upper half of iaoq[1] = %#lx\n", compat_regt); DBG(2,"restore_sigcontext32: sc->sc_iaoq[1] = %p => %#x\n", &sc->sc_iaoq[1],compat_reg); DBG(2,"restore_sigcontext32: iaoq is %#lx / %#lx\n", regs->iaoq[0],regs->iaoq[1]); err |= __get_user(compat_reg, &sc->sc_iasq[0]); /* Load the upper half for iasq */ err |= __get_user(compat_regt, &rf->rf_iasq[0]); regs->iasq[0] = ((u64)compat_regt << 32) | (u64)compat_reg; DBG(2,"restore_sigcontext32: upper half of iasq[0] = %#lx\n", compat_regt); err |= __get_user(compat_reg, &sc->sc_iasq[1]); /* Load the upper half for iasq */ err |= __get_user(compat_regt, &rf->rf_iasq[1]); regs->iasq[1] = ((u64)compat_regt << 32) | (u64)compat_reg; DBG(2,"restore_sigcontext32: upper half of iasq[1] = %#lx\n", compat_regt); DBG(2,"restore_sigcontext32: iasq is %#lx / %#lx\n", regs->iasq[0],regs->iasq[1]); err |= __get_user(compat_reg, &sc->sc_sar); /* Load the upper half for sar */ err |= __get_user(compat_regt, &rf->rf_sar); regs->sar = ((u64)compat_regt << 32) | (u64)compat_reg; DBG(2,"restore_sigcontext32: upper_half & sar = %#lx\n", compat_regt); DBG(2,"restore_sigcontext32: sar is %#lx\n", regs->sar); DBG(2,"restore_sigcontext32: r28 is %ld\n", regs->gr[28]); return err; } /* * Set up the sigcontext structure for this process. * This is not an easy task if the kernel is 64-bit, it will require * that we examine the process personality to determine if we need to * truncate for a 32-bit userspace. */ long setup_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf, struct pt_regs *regs, int in_syscall) { compat_int_t flags = 0; long err = 0; compat_uint_t compat_reg; compat_uint_t compat_regb; int regn; if (on_sig_stack((unsigned long) sc)) flags |= PARISC_SC_FLAG_ONSTACK; if (in_syscall) { DBG(1,"setup_sigcontext32: in_syscall\n"); flags |= PARISC_SC_FLAG_IN_SYSCALL; /* Truncate gr31 */ compat_reg = (compat_uint_t)(regs->gr[31]); /* regs->iaoq is undefined in the syscall return path */ err |= __put_user(compat_reg, &sc->sc_iaoq[0]); DBG(2,"setup_sigcontext32: sc->sc_iaoq[0] = %p <= %#x\n", &sc->sc_iaoq[0], compat_reg); /* Store upper half */ compat_reg = (compat_uint_t)(regs->gr[31] >> 32); err |= __put_user(compat_reg, &rf->rf_iaoq[0]); DBG(2,"setup_sigcontext32: upper half iaoq[0] = %#x\n", compat_reg); compat_reg = (compat_uint_t)(regs->gr[31]+4); err |= __put_user(compat_reg, &sc->sc_iaoq[1]); DBG(2,"setup_sigcontext32: sc->sc_iaoq[1] = %p <= %#x\n", &sc->sc_iaoq[1], compat_reg); /* Store upper half */ compat_reg = (compat_uint_t)((regs->gr[31]+4) >> 32); err |= __put_user(compat_reg, &rf->rf_iaoq[1]); DBG(2,"setup_sigcontext32: upper half iaoq[1] = %#x\n", compat_reg); /* Truncate sr3 */ compat_reg = (compat_uint_t)(regs->sr[3]); err |= __put_user(compat_reg, &sc->sc_iasq[0]); err |= __put_user(compat_reg, &sc->sc_iasq[1]); /* Store upper half */ compat_reg = (compat_uint_t)(regs->sr[3] >> 32); err |= __put_user(compat_reg, &rf->rf_iasq[0]); err |= __put_user(compat_reg, &rf->rf_iasq[1]); DBG(2,"setup_sigcontext32: upper half iasq[0] = %#x\n", compat_reg); DBG(2,"setup_sigcontext32: upper half iasq[1] = %#x\n", compat_reg); DBG(1,"setup_sigcontext32: iaoq %#lx / %#lx\n", regs->gr[31], regs->gr[31]+4); } else { compat_reg = (compat_uint_t)(regs->iaoq[0]); err |= __put_user(compat_reg, &sc->sc_iaoq[0]); DBG(2,"setup_sigcontext32: sc->sc_iaoq[0] = %p <= %#x\n", &sc->sc_iaoq[0], compat_reg); /* Store upper half */ compat_reg = (compat_uint_t)(regs->iaoq[0] >> 32); err |= __put_user(compat_reg, &rf->rf_iaoq[0]); DBG(2,"setup_sigcontext32: upper half iaoq[0] = %#x\n", compat_reg); compat_reg = (compat_uint_t)(regs->iaoq[1]); err |= __put_user(compat_reg, &sc->sc_iaoq[1]); DBG(2,"setup_sigcontext32: sc->sc_iaoq[1] = %p <= %#x\n", &sc->sc_iaoq[1], compat_reg); /* Store upper half */ compat_reg = (compat_uint_t)(regs->iaoq[1] >> 32); err |= __put_user(compat_reg, &rf->rf_iaoq[1]); DBG(2,"setup_sigcontext32: upper half iaoq[1] = %#x\n", compat_reg); compat_reg = (compat_uint_t)(regs->iasq[0]); err |= __put_user(compat_reg, &sc->sc_iasq[0]); DBG(2,"setup_sigcontext32: sc->sc_iasq[0] = %p <= %#x\n", &sc->sc_iasq[0], compat_reg); /* Store upper half */ compat_reg = (compat_uint_t)(regs->iasq[0] >> 32); err |= __put_user(compat_reg, &rf->rf_iasq[0]); DBG(2,"setup_sigcontext32: upper half iasq[0] = %#x\n", compat_reg); compat_reg = (compat_uint_t)(regs->iasq[1]); err |= __put_user(compat_reg, &sc->sc_iasq[1]); DBG(2,"setup_sigcontext32: sc->sc_iasq[1] = %p <= %#x\n", &sc->sc_iasq[1], compat_reg); /* Store upper half */ compat_reg = (compat_uint_t)(regs->iasq[1] >> 32); err |= __put_user(compat_reg, &rf->rf_iasq[1]); DBG(2,"setup_sigcontext32: upper half iasq[1] = %#x\n", compat_reg); /* Print out the IAOQ for debugging */ DBG(1,"setup_sigcontext32: ia0q %#lx / %#lx\n", regs->iaoq[0], regs->iaoq[1]); } err |= __put_user(flags, &sc->sc_flags); DBG(1,"setup_sigcontext32: Truncating general registers.\n"); for(regn=0; regn < 32; regn++){ /* Truncate a general register */ compat_reg = (compat_uint_t)(regs->gr[regn]); err |= __put_user(compat_reg, &sc->sc_gr[regn]); /* Store upper half */ compat_regb = (compat_uint_t)(regs->gr[regn] >> 32); err |= __put_user(compat_regb, &rf->rf_gr[regn]); /* DEBUG: Write out the "upper / lower" register data */ DBG(2,"setup_sigcontext32: gr%02d = %#x / %#x\n", regn, compat_regb, compat_reg); } /* Copy the floating point registers (same size) XXX: BE WARNED FR's are 64-BIT! */ DBG(1,"setup_sigcontext32: Copying from regs to sc, " "sc->sc_fr size = %#lx, regs->fr size = %#lx\n", sizeof(regs->fr), sizeof(sc->sc_fr)); err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr)); compat_reg = (compat_uint_t)(regs->sar); err |= __put_user(compat_reg, &sc->sc_sar); DBG(2,"setup_sigcontext32: sar is %#x\n", compat_reg); /* Store upper half */ compat_reg = (compat_uint_t)(regs->sar >> 32); err |= __put_user(compat_reg, &rf->rf_sar); DBG(2,"setup_sigcontext32: upper half sar = %#x\n", compat_reg); DBG(1,"setup_sigcontext32: r28 is %ld\n", regs->gr[28]); return err; } int copy_siginfo_from_user32 (siginfo_t *to, compat_siginfo_t __user *from) { compat_uptr_t addr; int err; if (!access_ok(VERIFY_READ, from, sizeof(compat_siginfo_t))) return -EFAULT; err = __get_user(to->si_signo, &from->si_signo); err |= __get_user(to->si_errno, &from->si_errno); err |= __get_user(to->si_code, &from->si_code); if (to->si_code < 0) err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE); else { switch (to->si_code >> 16) { case __SI_CHLD >> 16: err |= __get_user(to->si_utime, &from->si_utime); err |= __get_user(to->si_stime, &from->si_stime); err |= __get_user(to->si_status, &from->si_status); default: err |= __get_user(to->si_pid, &from->si_pid); err |= __get_user(to->si_uid, &from->si_uid); break; case __SI_FAULT >> 16: err |= __get_user(addr, &from->si_addr); to->si_addr = compat_ptr(addr); break; case __SI_POLL >> 16: err |= __get_user(to->si_band, &from->si_band); err |= __get_user(to->si_fd, &from->si_fd); break; case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ case __SI_MESGQ >> 16: err |= __get_user(to->si_pid, &from->si_pid); err |= __get_user(to->si_uid, &from->si_uid); err |= __get_user(to->si_int, &from->si_int); break; } } return err; } int copy_siginfo_to_user32 (compat_siginfo_t __user *to, siginfo_t *from) { compat_uptr_t addr; compat_int_t val; int err; if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t))) return -EFAULT; /* If you change siginfo_t structure, please be sure this code is fixed accordingly. It should never copy any pad contained in the structure to avoid security leaks, but must copy the generic 3 ints plus the relevant union member. This routine must convert siginfo from 64bit to 32bit as well at the same time. */ err = __put_user(from->si_signo, &to->si_signo); err |= __put_user(from->si_errno, &to->si_errno); err |= __put_user((short)from->si_code, &to->si_code); if (from->si_code < 0) err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE); else { switch (from->si_code >> 16) { case __SI_CHLD >> 16: err |= __put_user(from->si_utime, &to->si_utime); err |= __put_user(from->si_stime, &to->si_stime); err |= __put_user(from->si_status, &to->si_status); default: err |= __put_user(from->si_pid, &to->si_pid); err |= __put_user(from->si_uid, &to->si_uid); break; case __SI_FAULT >> 16: addr = ptr_to_compat(from->si_addr); err |= __put_user(addr, &to->si_addr); break; case __SI_POLL >> 16: err |= __put_user(from->si_band, &to->si_band); err |= __put_user(from->si_fd, &to->si_fd); break; case __SI_TIMER >> 16: err |= __put_user(from->si_tid, &to->si_tid); err |= __put_user(from->si_overrun, &to->si_overrun); val = (compat_int_t)from->si_int; err |= __put_user(val, &to->si_int); break; case __SI_RT >> 16: /* Not generated by the kernel as of now. */ case __SI_MESGQ >> 16: err |= __put_user(from->si_uid, &to->si_uid); err |= __put_user(from->si_pid, &to->si_pid); val = (compat_int_t)from->si_int; err |= __put_user(val, &to->si_int); break; } } return err; } asmlinkage long compat_sys_rt_sigqueueinfo(int pid, int sig, struct compat_siginfo __user *uinfo) { siginfo_t info; if (copy_siginfo_from_user32(&info, uinfo)) return -EFAULT; /* Not even root can pretend to send signals from the kernel. Nor can they impersonate a kill(), which adds source info. */ if (info.si_code >= 0) return -EPERM; info.si_signo = sig; /* POSIX.1b doesn't mention process groups. */ return kill_proc_info(sig, &info, pid); }