arch/parisc/kernel/signal32.c

   1 /*    Signal support for 32-bit kernel builds
   2  *
   3  *    Copyright (C) 2001 Matthew Wilcox <willy at parisc-linux.org>
   4  *    Code was mostly borrowed from kernel/signal.c.
   5  *    See kernel/signal.c for additional Copyrights.
   6  *
   7  *
   8  *    This program is free software; you can redistribute it and/or modify
   9  *    it under the terms of the GNU General Public License as published by
  10  *    the Free Software Foundation; either version 2 of the License, or
  11  *    (at your option) any later version.
  12  *
  13  *    This program is distributed in the hope that it will be useful,
  14  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *    GNU General Public License for more details.
  17  *
  18  *    You should have received a copy of the GNU General Public License
  19  *    along with this program; if not, write to the Free Software
  20  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include <linux/compat.h>
  24 #include <linux/slab.h>
  25 #include <linux/module.h>
  26 #include <linux/unistd.h>
  27 #include <linux/smp_lock.h>
  28 #include <linux/init.h>
  29 #include <linux/sched.h>
  30 #include <linux/syscalls.h>
  31 #include <linux/types.h>
  32 #include <linux/errno.h>
  33
  34 #include <asm/compat_signal.h>
  35 #include <asm/uaccess.h>
  36
  37 #include "signal32.h"
  38 #include "sys32.h"
  39
  40 #define DEBUG_COMPAT_SIG 0
  41 #define DEBUG_COMPAT_SIG_LEVEL 2
  42
  43 #if DEBUG_COMPAT_SIG
  44 #define DBG(LEVEL, ...) \
  45         ((DEBUG_COMPAT_SIG_LEVEL >= LEVEL) \
  46         ? printk(__VA_ARGS__) : (void) 0)
  47 #else
  48 #define DBG(LEVEL, ...)
  49 #endif
  50
  51 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  52
  53 inline void
  54 sigset_32to64(sigset_t *s64, compat_sigset_t *s32)
  55 {
  56         s64->sig[0] = s32->sig[0] | ((unsigned long)s32->sig[1] << 32);
  57 }
  58
  59 inline void
  60 sigset_64to32(compat_sigset_t *s32, sigset_t *s64)
  61 {
  62         s32->sig[0] = s64->sig[0] & 0xffffffffUL;
  63         s32->sig[1] = (s64->sig[0] >> 32) & 0xffffffffUL;
  64 }
  65
  66 static int
  67 put_sigset32(compat_sigset_t __user *up, sigset_t *set, size_t sz)
  68 {
  69         compat_sigset_t s;
  70
  71         if (sz != sizeof *set) panic("put_sigset32()");
  72         sigset_64to32(&s, set);
  73
  74         return copy_to_user(up, &s, sizeof s);
  75 }
  76
  77 static int
  78 get_sigset32(compat_sigset_t __user *up, sigset_t *set, size_t sz)
  79 {
  80         compat_sigset_t s;
  81         int r;
  82
  83         if (sz != sizeof *set) panic("put_sigset32()");
  84
  85         if ((r = copy_from_user(&s, up, sz)) == 0) {
  86                 sigset_32to64(set, &s);
  87         }
  88
  89         return r;
  90 }
  91
  92 int sys32_rt_sigprocmask(int how, compat_sigset_t __user *set, compat_sigset_t __user *oset,
  93                                     unsigned int sigsetsize)
  94 {
  95         sigset_t old_set, new_set;
  96         int ret;
  97
  98         if (set && get_sigset32(set, &new_set, sigsetsize))
  99                 return -EFAULT;
 100
 101         KERNEL_SYSCALL(ret, sys_rt_sigprocmask, how, set ? (sigset_t __user *)&new_set : NULL,
 102                                  oset ? (sigset_t __user *)&old_set : NULL, sigsetsize);
 103
 104         if (!ret && oset && put_sigset32(oset, &old_set, sigsetsize))
 105                 return -EFAULT;
 106
 107         return ret;
 108 }
 109
 110
 111 int sys32_rt_sigpending(compat_sigset_t __user *uset, unsigned int sigsetsize)
 112 {
 113         int ret;
 114         sigset_t set;
 115
 116         KERNEL_SYSCALL(ret, sys_rt_sigpending, (sigset_t __user *)&set, sigsetsize);
 117
 118         if (!ret && put_sigset32(uset, &set, sigsetsize))
 119                 return -EFAULT;
 120
 121         return ret;
 122 }
 123
 124 long
 125 sys32_rt_sigaction(int sig, const struct sigaction32 __user *act, struct sigaction32 __user *oact,
 126                  size_t sigsetsize)
 127 {
 128         struct k_sigaction32 new_sa32, old_sa32;
 129         struct k_sigaction new_sa, old_sa;
 130         int ret = -EINVAL;
 131
 132         if (act) {
 133                 if (copy_from_user(&new_sa32.sa, act, sizeof new_sa32.sa))
 134                         return -EFAULT;
 135                 new_sa.sa.sa_handler = (__sighandler_t)(unsigned long)new_sa32.sa.sa_handler;
 136                 new_sa.sa.sa_flags = new_sa32.sa.sa_flags;
 137                 sigset_32to64(&new_sa.sa.sa_mask, &new_sa32.sa.sa_mask);
 138         }
 139
 140         ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
 141
 142         if (!ret && oact) {
 143                 sigset_64to32(&old_sa32.sa.sa_mask, &old_sa.sa.sa_mask);
 144                 old_sa32.sa.sa_flags = old_sa.sa.sa_flags;
 145                 old_sa32.sa.sa_handler = (__sighandler_t32)(unsigned long)old_sa.sa.sa_handler;
 146                 if (copy_to_user(oact, &old_sa32.sa, sizeof old_sa32.sa))
 147                         return -EFAULT;
 148         }
 149         return ret;
 150 }
 151
 152 int
 153 do_sigaltstack32 (const compat_stack_t __user *uss32, compat_stack_t __user *uoss32, unsigned long sp)
 154 {
 155         compat_stack_t ss32, oss32;
 156         stack_t ss, oss;
 157         stack_t *ssp = NULL, *ossp = NULL;
 158         int ret;
 159
 160         if (uss32) {
 161                 if (copy_from_user(&ss32, uss32, sizeof ss32))
 162                         return -EFAULT;
 163
 164                 ss.ss_sp = (void __user *)(unsigned long)ss32.ss_sp;
 165                 ss.ss_flags = ss32.ss_flags;
 166                 ss.ss_size = ss32.ss_size;
 167
 168                 ssp = &ss;
 169         }
 170
 171         if (uoss32)
 172                 ossp = &oss;
 173
 174         KERNEL_SYSCALL(ret, do_sigaltstack, (const stack_t __user *)ssp, (stack_t __user *)ossp, sp);
 175
 176         if (!ret && uoss32) {
 177                 oss32.ss_sp = (unsigned int)(unsigned long)oss.ss_sp;
 178                 oss32.ss_flags = oss.ss_flags;
 179                 oss32.ss_size = oss.ss_size;
 180                 if (copy_to_user(uoss32, &oss32, sizeof *uoss32))
 181                         return -EFAULT;
 182         }
 183
 184         return ret;
 185 }
 186
 187 long
 188 restore_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf,
 189                 struct pt_regs *regs)
 190 {
 191         long err = 0;
 192         compat_uint_t compat_reg;
 193         compat_uint_t compat_regt;
 194         int regn;
 195
 196         /* When loading 32-bit values into 64-bit registers make
 197            sure to clear the upper 32-bits */
 198         DBG(2,"restore_sigcontext32: PER_LINUX32 process\n");
 199         DBG(2,"restore_sigcontext32: sc = 0x%p, rf = 0x%p, regs = 0x%p\n", sc, rf, regs);
 200         DBG(2,"restore_sigcontext32: compat_sigcontext is %#lx bytes\n", sizeof(*sc));
 201         for(regn=0; regn < 32; regn++){
 202                 err |= __get_user(compat_reg,&sc->sc_gr[regn]);
 203                 regs->gr[regn] = compat_reg;
 204                 /* Load upper half */
 205                 err |= __get_user(compat_regt,&rf->rf_gr[regn]);
 206                 regs->gr[regn] = ((u64)compat_regt << 32) | (u64)compat_reg;
 207                 DBG(3,"restore_sigcontext32: gr%02d = %#lx (%#x / %#x)\n",
 208                                 regn, regs->gr[regn], compat_regt, compat_reg);
 209         }
 210         DBG(2,"restore_sigcontext32: sc->sc_fr = 0x%p (%#lx)\n",sc->sc_fr, sizeof(sc->sc_fr));
 211         /* XXX: BE WARNED FR's are 64-BIT! */
 212         err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr));
 213
 214         /* Better safe than sorry, pass __get_user two things of
 215            the same size and let gcc do the upward conversion to
 216            64-bits */
 217         err |= __get_user(compat_reg, &sc->sc_iaoq[0]);
 218         /* Load upper half */
 219         err |= __get_user(compat_regt, &rf->rf_iaoq[0]);
 220         regs->iaoq[0] = ((u64)compat_regt << 32) | (u64)compat_reg;
 221         DBG(2,"restore_sigcontext32: upper half of iaoq[0] = %#lx\n", compat_regt);
 222         DBG(2,"restore_sigcontext32: sc->sc_iaoq[0] = %p => %#x\n",
 223                         &sc->sc_iaoq[0], compat_reg);
 224
 225         err |= __get_user(compat_reg, &sc->sc_iaoq[1]);
 226         /* Load upper half */
 227         err |= __get_user(compat_regt, &rf->rf_iaoq[1]);
 228         regs->iaoq[1] = ((u64)compat_regt << 32) | (u64)compat_reg;
 229         DBG(2,"restore_sigcontext32: upper half of iaoq[1] = %#lx\n", compat_regt);
 230         DBG(2,"restore_sigcontext32: sc->sc_iaoq[1] = %p => %#x\n",
 231                         &sc->sc_iaoq[1],compat_reg);
 232         DBG(2,"restore_sigcontext32: iaoq is %#lx / %#lx\n",
 233                         regs->iaoq[0],regs->iaoq[1]);
 234
 235         err |= __get_user(compat_reg, &sc->sc_iasq[0]);
 236         /* Load the upper half for iasq */
 237         err |= __get_user(compat_regt, &rf->rf_iasq[0]);
 238         regs->iasq[0] = ((u64)compat_regt << 32) | (u64)compat_reg;
 239         DBG(2,"restore_sigcontext32: upper half of iasq[0] = %#lx\n", compat_regt);
 240
 241         err |= __get_user(compat_reg, &sc->sc_iasq[1]);
 242         /* Load the upper half for iasq */
 243         err |= __get_user(compat_regt, &rf->rf_iasq[1]);
 244         regs->iasq[1] = ((u64)compat_regt << 32) | (u64)compat_reg;
 245         DBG(2,"restore_sigcontext32: upper half of iasq[1] = %#lx\n", compat_regt);
 246         DBG(2,"restore_sigcontext32: iasq is %#lx / %#lx\n",
 247                 regs->iasq[0],regs->iasq[1]);
 248
 249         err |= __get_user(compat_reg, &sc->sc_sar);
 250         /* Load the upper half for sar */
 251         err |= __get_user(compat_regt, &rf->rf_sar);
 252         regs->sar = ((u64)compat_regt << 32) | (u64)compat_reg;
 253         DBG(2,"restore_sigcontext32: upper_half & sar = %#lx\n", compat_regt);
 254         DBG(2,"restore_sigcontext32: sar is %#lx\n", regs->sar);
 255         DBG(2,"restore_sigcontext32: r28 is %ld\n", regs->gr[28]);
 256
 257         return err;
 258 }
 259
 260 /*
 261  * Set up the sigcontext structure for this process.
 262  * This is not an easy task if the kernel is 64-bit, it will require
 263  * that we examine the process personality to determine if we need to
 264  * truncate for a 32-bit userspace.
 265  */
 266 long
 267 setup_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf,
 268                 struct pt_regs *regs, int in_syscall)
 269 {
 270         compat_int_t flags = 0;
 271         long err = 0;
 272         compat_uint_t compat_reg;
 273         compat_uint_t compat_regb;
 274         int regn;
 275
 276         if (on_sig_stack((unsigned long) sc))
 277                 flags |= PARISC_SC_FLAG_ONSTACK;
 278
 279         if (in_syscall) {
 280
 281                 DBG(1,"setup_sigcontext32: in_syscall\n");
 282
 283                 flags |= PARISC_SC_FLAG_IN_SYSCALL;
 284                 /* Truncate gr31 */
 285                 compat_reg = (compat_uint_t)(regs->gr[31]);
 286                 /* regs->iaoq is undefined in the syscall return path */
 287                 err |= __put_user(compat_reg, &sc->sc_iaoq[0]);
 288                 DBG(2,"setup_sigcontext32: sc->sc_iaoq[0] = %p <= %#x\n",
 289                                 &sc->sc_iaoq[0], compat_reg);
 290
 291                 /* Store upper half */
 292                 compat_reg = (compat_uint_t)(regs->gr[32] >> 32);
 293                 err |= __put_user(compat_reg, &rf->rf_iaoq[0]);
 294                 DBG(2,"setup_sigcontext32: upper half iaoq[0] = %#x\n", compat_reg);
 295
 296
 297                 compat_reg = (compat_uint_t)(regs->gr[31]+4);
 298                 err |= __put_user(compat_reg, &sc->sc_iaoq[1]);
 299                 DBG(2,"setup_sigcontext32: sc->sc_iaoq[1] = %p <= %#x\n",
 300                                 &sc->sc_iaoq[1], compat_reg);
 301                 /* Store upper half */
 302                 compat_reg = (compat_uint_t)((regs->gr[32]+4) >> 32);
 303                 err |= __put_user(compat_reg, &rf->rf_iaoq[1]);
 304                 DBG(2,"setup_sigcontext32: upper half iaoq[1] = %#x\n", compat_reg);
 305
 306                 /* Truncate sr3 */
 307                 compat_reg = (compat_uint_t)(regs->sr[3]);
 308                 err |= __put_user(compat_reg, &sc->sc_iasq[0]);
 309                 err |= __put_user(compat_reg, &sc->sc_iasq[1]);
 310
 311                 /* Store upper half */
 312                 compat_reg = (compat_uint_t)(regs->sr[3] >> 32);
 313                 err |= __put_user(compat_reg, &rf->rf_iasq[0]);
 314                 err |= __put_user(compat_reg, &rf->rf_iasq[1]);
 315
 316                 DBG(2,"setup_sigcontext32: upper half iasq[0] = %#x\n", compat_reg);
 317                 DBG(2,"setup_sigcontext32: upper half iasq[1] = %#x\n", compat_reg);
 318                 DBG(1,"setup_sigcontext32: iaoq %#lx / %#lx\n",
 319                         regs->gr[31], regs->gr[31]+4);
 320
 321         } else {
 322
 323                 compat_reg = (compat_uint_t)(regs->iaoq[0]);
 324                 err |= __put_user(compat_reg, &sc->sc_iaoq[0]);
 325                 DBG(2,"setup_sigcontext32: sc->sc_iaoq[0] = %p <= %#x\n",
 326                                 &sc->sc_iaoq[0], compat_reg);
 327                 /* Store upper half */
 328                 compat_reg = (compat_uint_t)(regs->iaoq[0] >> 32);
 329                 err |= __put_user(compat_reg, &rf->rf_iaoq[0]);
 330                 DBG(2,"setup_sigcontext32: upper half iaoq[0] = %#x\n", compat_reg);
 331
 332                 compat_reg = (compat_uint_t)(regs->iaoq[1]);
 333                 err |= __put_user(compat_reg, &sc->sc_iaoq[1]);
 334                 DBG(2,"setup_sigcontext32: sc->sc_iaoq[1] = %p <= %#x\n",
 335                                 &sc->sc_iaoq[1], compat_reg);
 336                 /* Store upper half */
 337                 compat_reg = (compat_uint_t)(regs->iaoq[1] >> 32);
 338                 err |= __put_user(compat_reg, &rf->rf_iaoq[1]);
 339                 DBG(2,"setup_sigcontext32: upper half iaoq[1] = %#x\n", compat_reg);
 340
 341
 342                 compat_reg = (compat_uint_t)(regs->iasq[0]);
 343                 err |= __put_user(compat_reg, &sc->sc_iasq[0]);
 344                 DBG(2,"setup_sigcontext32: sc->sc_iasq[0] = %p <= %#x\n",
 345                                 &sc->sc_iasq[0], compat_reg);
 346                 /* Store upper half */
 347                 compat_reg = (compat_uint_t)(regs->iasq[0] >> 32);
 348                 err |= __put_user(compat_reg, &rf->rf_iasq[0]);
 349                 DBG(2,"setup_sigcontext32: upper half iasq[0] = %#x\n", compat_reg);
 350
 351
 352                 compat_reg = (compat_uint_t)(regs->iasq[1]);
 353                 err |= __put_user(compat_reg, &sc->sc_iasq[1]);
 354                 DBG(2,"setup_sigcontext32: sc->sc_iasq[1] = %p <= %#x\n",
 355                                 &sc->sc_iasq[1], compat_reg);
 356                 /* Store upper half */
 357                 compat_reg = (compat_uint_t)(regs->iasq[1] >> 32);
 358                 err |= __put_user(compat_reg, &rf->rf_iasq[1]);
 359                 DBG(2,"setup_sigcontext32: upper half iasq[1] = %#x\n", compat_reg);
 360
 361                 /* Print out the IAOQ for debugging */
 362                 DBG(1,"setup_sigcontext32: ia0q %#lx / %#lx\n",
 363                         regs->iaoq[0], regs->iaoq[1]);
 364         }
 365
 366         err |= __put_user(flags, &sc->sc_flags);
 367
 368         DBG(1,"setup_sigcontext32: Truncating general registers.\n");
 369
 370         for(regn=0; regn < 32; regn++){
 371                 /* Truncate a general register */
 372                 compat_reg = (compat_uint_t)(regs->gr[regn]);
 373                 err |= __put_user(compat_reg, &sc->sc_gr[regn]);
 374                 /* Store upper half */
 375                 compat_regb = (compat_uint_t)(regs->gr[regn] >> 32);
 376                 err |= __put_user(compat_regb, &rf->rf_gr[regn]);
 377
 378                 /* DEBUG: Write out the "upper / lower" register data */
 379                 DBG(2,"setup_sigcontext32: gr%02d = %#x / %#x\n", regn,
 380                                 compat_regb, compat_reg);
 381         }
 382
 383         /* Copy the floating point registers (same size)
 384            XXX: BE WARNED FR's are 64-BIT! */
 385         DBG(1,"setup_sigcontext32: Copying from regs to sc, "
 386               "sc->sc_fr size = %#lx, regs->fr size = %#lx\n",
 387                 sizeof(regs->fr), sizeof(sc->sc_fr));
 388         err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr));
 389
 390         compat_reg = (compat_uint_t)(regs->sar);
 391         err |= __put_user(compat_reg, &sc->sc_sar);
 392         DBG(2,"setup_sigcontext32: sar is %#x\n", compat_reg);
 393         /* Store upper half */
 394         compat_reg = (compat_uint_t)(regs->sar >> 32);
 395         err |= __put_user(compat_reg, &rf->rf_sar);
 396         DBG(2,"setup_sigcontext32: upper half sar = %#x\n", compat_reg);
 397         DBG(1,"setup_sigcontext32: r28 is %ld\n", regs->gr[28]);
 398
 399         return err;
 400 }