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  *    Copyright (C) 2006 Kyle McMartin <kyle at parisc-linux.org>
   5  *
   6  *    Code was mostly borrowed from kernel/signal.c.
   7  *    See kernel/signal.c for additional Copyrights.
   8  *
   9  *
  10  *    This program is free software; you can redistribute it and/or modify
  11  *    it under the terms of the GNU General Public License as published by
  12  *    the Free Software Foundation; either version 2 of the License, or
  13  *    (at your option) any later version.
  14  *
  15  *    This program is distributed in the hope that it will be useful,
  16  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *    GNU General Public License for more details.
  19  *
  20  *    You should have received a copy of the GNU General Public License
  21  *    along with this program; if not, write to the Free Software
  22  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 #include <linux/compat.h>
  26 #include <linux/module.h>
  27 #include <linux/unistd.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/uaccess.h>
  35
  36 #include "signal32.h"
  37 #include "sys32.h"
  38
  39 #define DEBUG_COMPAT_SIG 0
  40 #define DEBUG_COMPAT_SIG_LEVEL 2
  41
  42 #if DEBUG_COMPAT_SIG
  43 #define DBG(LEVEL, ...) \
  44         ((DEBUG_COMPAT_SIG_LEVEL >= LEVEL) \
  45         ? printk(__VA_ARGS__) : (void) 0)
  46 #else
  47 #define DBG(LEVEL, ...)
  48 #endif
  49
  50 inline void
  51 sigset_32to64(sigset_t *s64, compat_sigset_t *s32)
  52 {
  53         s64->sig[0] = s32->sig[0] | ((unsigned long)s32->sig[1] << 32);
  54 }
  55
  56 inline void
  57 sigset_64to32(compat_sigset_t *s32, sigset_t *s64)
  58 {
  59         s32->sig[0] = s64->sig[0] & 0xffffffffUL;
  60         s32->sig[1] = (s64->sig[0] >> 32) & 0xffffffffUL;
  61 }
  62
  63 long
  64 restore_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf,
  65                 struct pt_regs *regs)
  66 {
  67         long err = 0;
  68         compat_uint_t compat_reg;
  69         compat_uint_t compat_regt;
  70         int regn;
  71
  72         /* When loading 32-bit values into 64-bit registers make
  73            sure to clear the upper 32-bits */
  74         DBG(2,"restore_sigcontext32: PER_LINUX32 process\n");
  75         DBG(2,"restore_sigcontext32: sc = 0x%p, rf = 0x%p, regs = 0x%p\n", sc, rf, regs);
  76         DBG(2,"restore_sigcontext32: compat_sigcontext is %#lx bytes\n", sizeof(*sc));
  77         for(regn=0; regn < 32; regn++){
  78                 err |= __get_user(compat_reg,&sc->sc_gr[regn]);
  79                 regs->gr[regn] = compat_reg;
  80                 /* Load upper half */
  81                 err |= __get_user(compat_regt,&rf->rf_gr[regn]);
  82                 regs->gr[regn] = ((u64)compat_regt << 32) | (u64)compat_reg;
  83                 DBG(3,"restore_sigcontext32: gr%02d = %#lx (%#x / %#x)\n",
  84                                 regn, regs->gr[regn], compat_regt, compat_reg);
  85         }
  86         DBG(2,"restore_sigcontext32: sc->sc_fr = 0x%p (%#lx)\n",sc->sc_fr, sizeof(sc->sc_fr));
  87         /* XXX: BE WARNED FR's are 64-BIT! */
  88         err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr));
  89
  90         /* Better safe than sorry, pass __get_user two things of
  91            the same size and let gcc do the upward conversion to
  92            64-bits */
  93         err |= __get_user(compat_reg, &sc->sc_iaoq[0]);
  94         /* Load upper half */
  95         err |= __get_user(compat_regt, &rf->rf_iaoq[0]);
  96         regs->iaoq[0] = ((u64)compat_regt << 32) | (u64)compat_reg;
  97         DBG(2,"restore_sigcontext32: upper half of iaoq[0] = %#lx\n", compat_regt);
  98         DBG(2,"restore_sigcontext32: sc->sc_iaoq[0] = %p => %#x\n",
  99                         &sc->sc_iaoq[0], compat_reg);
 100
 101         err |= __get_user(compat_reg, &sc->sc_iaoq[1]);
 102         /* Load upper half */
 103         err |= __get_user(compat_regt, &rf->rf_iaoq[1]);
 104         regs->iaoq[1] = ((u64)compat_regt << 32) | (u64)compat_reg;
 105         DBG(2,"restore_sigcontext32: upper half of iaoq[1] = %#lx\n", compat_regt);
 106         DBG(2,"restore_sigcontext32: sc->sc_iaoq[1] = %p => %#x\n",
 107                         &sc->sc_iaoq[1],compat_reg);
 108         DBG(2,"restore_sigcontext32: iaoq is %#lx / %#lx\n",
 109                         regs->iaoq[0],regs->iaoq[1]);
 110
 111         err |= __get_user(compat_reg, &sc->sc_iasq[0]);
 112         /* Load the upper half for iasq */
 113         err |= __get_user(compat_regt, &rf->rf_iasq[0]);
 114         regs->iasq[0] = ((u64)compat_regt << 32) | (u64)compat_reg;
 115         DBG(2,"restore_sigcontext32: upper half of iasq[0] = %#lx\n", compat_regt);
 116
 117         err |= __get_user(compat_reg, &sc->sc_iasq[1]);
 118         /* Load the upper half for iasq */
 119         err |= __get_user(compat_regt, &rf->rf_iasq[1]);
 120         regs->iasq[1] = ((u64)compat_regt << 32) | (u64)compat_reg;
 121         DBG(2,"restore_sigcontext32: upper half of iasq[1] = %#lx\n", compat_regt);
 122         DBG(2,"restore_sigcontext32: iasq is %#lx / %#lx\n",
 123                 regs->iasq[0],regs->iasq[1]);
 124
 125         err |= __get_user(compat_reg, &sc->sc_sar);
 126         /* Load the upper half for sar */
 127         err |= __get_user(compat_regt, &rf->rf_sar);
 128         regs->sar = ((u64)compat_regt << 32) | (u64)compat_reg;
 129         DBG(2,"restore_sigcontext32: upper_half & sar = %#lx\n", compat_regt);
 130         DBG(2,"restore_sigcontext32: sar is %#lx\n", regs->sar);
 131         DBG(2,"restore_sigcontext32: r28 is %ld\n", regs->gr[28]);
 132
 133         return err;
 134 }
 135
 136 /*
 137  * Set up the sigcontext structure for this process.
 138  * This is not an easy task if the kernel is 64-bit, it will require
 139  * that we examine the process personality to determine if we need to
 140  * truncate for a 32-bit userspace.
 141  */
 142 long
 143 setup_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf,
 144                 struct pt_regs *regs, int in_syscall)
 145 {
 146         compat_int_t flags = 0;
 147         long err = 0;
 148         compat_uint_t compat_reg;
 149         compat_uint_t compat_regb;
 150         int regn;
 151
 152         if (on_sig_stack((unsigned long) sc))
 153                 flags |= PARISC_SC_FLAG_ONSTACK;
 154
 155         if (in_syscall) {
 156
 157                 DBG(1,"setup_sigcontext32: in_syscall\n");
 158
 159                 flags |= PARISC_SC_FLAG_IN_SYSCALL;
 160                 /* Truncate gr31 */
 161                 compat_reg = (compat_uint_t)(regs->gr[31]);
 162                 /* regs->iaoq is undefined in the syscall return path */
 163                 err |= __put_user(compat_reg, &sc->sc_iaoq[0]);
 164                 DBG(2,"setup_sigcontext32: sc->sc_iaoq[0] = %p <= %#x\n",
 165                                 &sc->sc_iaoq[0], compat_reg);
 166
 167                 /* Store upper half */
 168                 compat_reg = (compat_uint_t)(regs->gr[31] >> 32);
 169                 err |= __put_user(compat_reg, &rf->rf_iaoq[0]);
 170                 DBG(2,"setup_sigcontext32: upper half iaoq[0] = %#x\n", compat_reg);
 171
 172
 173                 compat_reg = (compat_uint_t)(regs->gr[31]+4);
 174                 err |= __put_user(compat_reg, &sc->sc_iaoq[1]);
 175                 DBG(2,"setup_sigcontext32: sc->sc_iaoq[1] = %p <= %#x\n",
 176                                 &sc->sc_iaoq[1], compat_reg);
 177                 /* Store upper half */
 178                 compat_reg = (compat_uint_t)((regs->gr[31]+4) >> 32);
 179                 err |= __put_user(compat_reg, &rf->rf_iaoq[1]);
 180                 DBG(2,"setup_sigcontext32: upper half iaoq[1] = %#x\n", compat_reg);
 181
 182                 /* Truncate sr3 */
 183                 compat_reg = (compat_uint_t)(regs->sr[3]);
 184                 err |= __put_user(compat_reg, &sc->sc_iasq[0]);
 185                 err |= __put_user(compat_reg, &sc->sc_iasq[1]);
 186
 187                 /* Store upper half */
 188                 compat_reg = (compat_uint_t)(regs->sr[3] >> 32);
 189                 err |= __put_user(compat_reg, &rf->rf_iasq[0]);
 190                 err |= __put_user(compat_reg, &rf->rf_iasq[1]);
 191
 192                 DBG(2,"setup_sigcontext32: upper half iasq[0] = %#x\n", compat_reg);
 193                 DBG(2,"setup_sigcontext32: upper half iasq[1] = %#x\n", compat_reg);
 194                 DBG(1,"setup_sigcontext32: iaoq %#lx / %#lx\n",
 195                         regs->gr[31], regs->gr[31]+4);
 196
 197         } else {
 198
 199                 compat_reg = (compat_uint_t)(regs->iaoq[0]);
 200                 err |= __put_user(compat_reg, &sc->sc_iaoq[0]);
 201                 DBG(2,"setup_sigcontext32: sc->sc_iaoq[0] = %p <= %#x\n",
 202                                 &sc->sc_iaoq[0], compat_reg);
 203                 /* Store upper half */
 204                 compat_reg = (compat_uint_t)(regs->iaoq[0] >> 32);
 205                 err |= __put_user(compat_reg, &rf->rf_iaoq[0]);
 206                 DBG(2,"setup_sigcontext32: upper half iaoq[0] = %#x\n", compat_reg);
 207
 208                 compat_reg = (compat_uint_t)(regs->iaoq[1]);
 209                 err |= __put_user(compat_reg, &sc->sc_iaoq[1]);
 210                 DBG(2,"setup_sigcontext32: sc->sc_iaoq[1] = %p <= %#x\n",
 211                                 &sc->sc_iaoq[1], compat_reg);
 212                 /* Store upper half */
 213                 compat_reg = (compat_uint_t)(regs->iaoq[1] >> 32);
 214                 err |= __put_user(compat_reg, &rf->rf_iaoq[1]);
 215                 DBG(2,"setup_sigcontext32: upper half iaoq[1] = %#x\n", compat_reg);
 216
 217
 218                 compat_reg = (compat_uint_t)(regs->iasq[0]);
 219                 err |= __put_user(compat_reg, &sc->sc_iasq[0]);
 220                 DBG(2,"setup_sigcontext32: sc->sc_iasq[0] = %p <= %#x\n",
 221                                 &sc->sc_iasq[0], compat_reg);
 222                 /* Store upper half */
 223                 compat_reg = (compat_uint_t)(regs->iasq[0] >> 32);
 224                 err |= __put_user(compat_reg, &rf->rf_iasq[0]);
 225                 DBG(2,"setup_sigcontext32: upper half iasq[0] = %#x\n", compat_reg);
 226
 227
 228                 compat_reg = (compat_uint_t)(regs->iasq[1]);
 229                 err |= __put_user(compat_reg, &sc->sc_iasq[1]);
 230                 DBG(2,"setup_sigcontext32: sc->sc_iasq[1] = %p <= %#x\n",
 231                                 &sc->sc_iasq[1], compat_reg);
 232                 /* Store upper half */
 233                 compat_reg = (compat_uint_t)(regs->iasq[1] >> 32);
 234                 err |= __put_user(compat_reg, &rf->rf_iasq[1]);
 235                 DBG(2,"setup_sigcontext32: upper half iasq[1] = %#x\n", compat_reg);
 236
 237                 /* Print out the IAOQ for debugging */
 238                 DBG(1,"setup_sigcontext32: ia0q %#lx / %#lx\n",
 239                         regs->iaoq[0], regs->iaoq[1]);
 240         }
 241
 242         err |= __put_user(flags, &sc->sc_flags);
 243
 244         DBG(1,"setup_sigcontext32: Truncating general registers.\n");
 245
 246         for(regn=0; regn < 32; regn++){
 247                 /* Truncate a general register */
 248                 compat_reg = (compat_uint_t)(regs->gr[regn]);
 249                 err |= __put_user(compat_reg, &sc->sc_gr[regn]);
 250                 /* Store upper half */
 251                 compat_regb = (compat_uint_t)(regs->gr[regn] >> 32);
 252                 err |= __put_user(compat_regb, &rf->rf_gr[regn]);
 253
 254                 /* DEBUG: Write out the "upper / lower" register data */
 255                 DBG(2,"setup_sigcontext32: gr%02d = %#x / %#x\n", regn,
 256                                 compat_regb, compat_reg);
 257         }
 258
 259         /* Copy the floating point registers (same size)
 260            XXX: BE WARNED FR's are 64-BIT! */
 261         DBG(1,"setup_sigcontext32: Copying from regs to sc, "
 262               "sc->sc_fr size = %#lx, regs->fr size = %#lx\n",
 263                 sizeof(regs->fr), sizeof(sc->sc_fr));
 264         err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr));
 265
 266         compat_reg = (compat_uint_t)(regs->sar);
 267         err |= __put_user(compat_reg, &sc->sc_sar);
 268         DBG(2,"setup_sigcontext32: sar is %#x\n", compat_reg);
 269         /* Store upper half */
 270         compat_reg = (compat_uint_t)(regs->sar >> 32);
 271         err |= __put_user(compat_reg, &rf->rf_sar);
 272         DBG(2,"setup_sigcontext32: upper half sar = %#x\n", compat_reg);
 273         DBG(1,"setup_sigcontext32: r28 is %ld\n", regs->gr[28]);
 274
 275         return err;
 276 }
 277
 278 int
 279 copy_siginfo_from_user32 (siginfo_t *to, compat_siginfo_t __user *from)
 280 {
 281         compat_uptr_t addr;
 282         int err;
 283
 284         if (!access_ok(VERIFY_READ, from, sizeof(compat_siginfo_t)))
 285                 return -EFAULT;
 286
 287         err = __get_user(to->si_signo, &from->si_signo);
 288         err |= __get_user(to->si_errno, &from->si_errno);
 289         err |= __get_user(to->si_code, &from->si_code);
 290
 291         if (to->si_code < 0)
 292                 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
 293         else {
 294                 switch (to->si_code >> 16) {
 295                       case __SI_CHLD >> 16:
 296                         err |= __get_user(to->si_utime, &from->si_utime);
 297                         err |= __get_user(to->si_stime, &from->si_stime);
 298                         err |= __get_user(to->si_status, &from->si_status);
 299                       default:
 300                         err |= __get_user(to->si_pid, &from->si_pid);
 301                         err |= __get_user(to->si_uid, &from->si_uid);
 302                         break;
 303                       case __SI_FAULT >> 16:
 304                         err |= __get_user(addr, &from->si_addr);
 305                         to->si_addr = compat_ptr(addr);
 306                         break;
 307                       case __SI_POLL >> 16:
 308                         err |= __get_user(to->si_band, &from->si_band);
 309                         err |= __get_user(to->si_fd, &from->si_fd);
 310                         break;
 311                       case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
 312                       case __SI_MESGQ >> 16:
 313                         err |= __get_user(to->si_pid, &from->si_pid);
 314                         err |= __get_user(to->si_uid, &from->si_uid);
 315                         err |= __get_user(to->si_int, &from->si_int);
 316                         break;
 317                 }
 318         }
 319         return err;
 320 }
 321
 322 int
 323 copy_siginfo_to_user32 (compat_siginfo_t __user *to, siginfo_t *from)
 324 {
 325         compat_uptr_t addr;
 326         compat_int_t val;
 327         int err;
 328
 329         if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
 330                 return -EFAULT;
 331
 332         /* If you change siginfo_t structure, please be sure
 333            this code is fixed accordingly.
 334            It should never copy any pad contained in the structure
 335            to avoid security leaks, but must copy the generic
 336            3 ints plus the relevant union member.
 337            This routine must convert siginfo from 64bit to 32bit as well
 338            at the same time.  */
 339         err = __put_user(from->si_signo, &to->si_signo);
 340         err |= __put_user(from->si_errno, &to->si_errno);
 341         err |= __put_user((short)from->si_code, &to->si_code);
 342         if (from->si_code < 0)
 343                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
 344         else {
 345                 switch (from->si_code >> 16) {
 346                 case __SI_CHLD >> 16:
 347                         err |= __put_user(from->si_utime, &to->si_utime);
 348                         err |= __put_user(from->si_stime, &to->si_stime);
 349                         err |= __put_user(from->si_status, &to->si_status);
 350                 default:
 351                         err |= __put_user(from->si_pid, &to->si_pid);
 352                         err |= __put_user(from->si_uid, &to->si_uid);
 353                         break;
 354                 case __SI_FAULT >> 16:
 355                         addr = ptr_to_compat(from->si_addr);
 356                         err |= __put_user(addr, &to->si_addr);
 357                         break;
 358                 case __SI_POLL >> 16:
 359                         err |= __put_user(from->si_band, &to->si_band);
 360                         err |= __put_user(from->si_fd, &to->si_fd);
 361                         break;
 362                 case __SI_TIMER >> 16:
 363                         err |= __put_user(from->si_tid, &to->si_tid);
 364                         err |= __put_user(from->si_overrun, &to->si_overrun);
 365                         val = (compat_int_t)from->si_int;
 366                         err |= __put_user(val, &to->si_int);
 367                         break;
 368                 case __SI_RT >> 16:     /* Not generated by the kernel as of now.  */
 369                 case __SI_MESGQ >> 16:
 370                         err |= __put_user(from->si_uid, &to->si_uid);
 371                         err |= __put_user(from->si_pid, &to->si_pid);
 372                         val = (compat_int_t)from->si_int;
 373                         err |= __put_user(val, &to->si_int);
 374                         break;
 375                 }
 376         }
 377         return err;
 378 }