arch/mips/kernel/signal32.c

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  *
   6  * Copyright (C) 1991, 1992  Linus Torvalds
   7  * Copyright (C) 1994 - 2000, 2006  Ralf Baechle
   8  * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
   9  */
  10 #include <linux/cache.h>
  11 #include <linux/compat.h>
  12 #include <linux/sched.h>
  13 #include <linux/mm.h>
  14 #include <linux/smp.h>
  15 #include <linux/kernel.h>
  16 #include <linux/signal.h>
  17 #include <linux/syscalls.h>
  18 #include <linux/errno.h>
  19 #include <linux/wait.h>
  20 #include <linux/ptrace.h>
  21 #include <linux/suspend.h>
  22 #include <linux/compiler.h>
  23 #include <linux/uaccess.h>
  24
  25 #include <asm/abi.h>
  26 #include <asm/asm.h>
  27 #include <asm/compat-signal.h>
  28 #include <linux/bitops.h>
  29 #include <asm/cacheflush.h>
  30 #include <asm/sim.h>
  31 #include <asm/ucontext.h>
  32 #include <asm/fpu.h>
  33 #include <asm/war.h>
  34 #include <asm/vdso.h>
  35 #include <asm/dsp.h>
  36
  37 #include "signal-common.h"
  38
  39 /*
  40  * Including <asm/unistd.h> would give use the 64-bit syscall numbers ...
  41  */
  42 #define __NR_O32_restart_syscall        4253
  43
  44 /* 32-bit compatibility types */
  45
  46 typedef unsigned int __sighandler32_t;
  47 typedef void (*vfptr_t)(void);
  48
  49 struct ucontext32 {
  50         u32                 uc_flags;
  51         s32                 uc_link;
  52         compat_stack_t      uc_stack;
  53         struct sigcontext32 uc_mcontext;
  54         compat_sigset_t     uc_sigmask;   /* mask last for extensibility */
  55 };
  56
  57 struct sigframe32 {
  58         u32 sf_ass[4];          /* argument save space for o32 */
  59         u32 sf_pad[2];          /* Was: signal trampoline */
  60         struct sigcontext32 sf_sc;
  61         compat_sigset_t sf_mask;
  62 };
  63
  64 struct rt_sigframe32 {
  65         u32 rs_ass[4];                  /* argument save space for o32 */
  66         u32 rs_pad[2];                  /* Was: signal trampoline */
  67         compat_siginfo_t rs_info;
  68         struct ucontext32 rs_uc;
  69 };
  70
  71 static int setup_sigcontext32(struct pt_regs *regs,
  72                               struct sigcontext32 __user *sc)
  73 {
  74         int err = 0;
  75         int i;
  76
  77         err |= __put_user(regs->cp0_epc, &sc->sc_pc);
  78
  79         err |= __put_user(0, &sc->sc_regs[0]);
  80         for (i = 1; i < 32; i++)
  81                 err |= __put_user(regs->regs[i], &sc->sc_regs[i]);
  82
  83         err |= __put_user(regs->hi, &sc->sc_mdhi);
  84         err |= __put_user(regs->lo, &sc->sc_mdlo);
  85         if (cpu_has_dsp) {
  86                 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
  87                 err |= __put_user(mfhi1(), &sc->sc_hi1);
  88                 err |= __put_user(mflo1(), &sc->sc_lo1);
  89                 err |= __put_user(mfhi2(), &sc->sc_hi2);
  90                 err |= __put_user(mflo2(), &sc->sc_lo2);
  91                 err |= __put_user(mfhi3(), &sc->sc_hi3);
  92                 err |= __put_user(mflo3(), &sc->sc_lo3);
  93         }
  94
  95         /*
  96          * Save FPU state to signal context.  Signal handler
  97          * will "inherit" current FPU state.
  98          */
  99         err |= protected_save_fp_context(sc);
 100
 101         return err;
 102 }
 103
 104 static int restore_sigcontext32(struct pt_regs *regs,
 105                                 struct sigcontext32 __user *sc)
 106 {
 107         int err = 0;
 108         s32 treg;
 109         int i;
 110
 111         /* Always make any pending restarted system calls return -EINTR */
 112         current->restart_block.fn = do_no_restart_syscall;
 113
 114         err |= __get_user(regs->cp0_epc, &sc->sc_pc);
 115         err |= __get_user(regs->hi, &sc->sc_mdhi);
 116         err |= __get_user(regs->lo, &sc->sc_mdlo);
 117         if (cpu_has_dsp) {
 118                 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
 119                 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
 120                 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
 121                 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
 122                 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
 123                 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
 124                 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
 125         }
 126
 127         for (i = 1; i < 32; i++)
 128                 err |= __get_user(regs->regs[i], &sc->sc_regs[i]);
 129
 130         return err ?: protected_restore_fp_context(sc);
 131 }
 132
 133 /*
 134  *
 135  */
 136 extern void __put_sigset_unknown_nsig(void);
 137 extern void __get_sigset_unknown_nsig(void);
 138
 139 static inline int put_sigset(const sigset_t *kbuf, compat_sigset_t __user *ubuf)
 140 {
 141         int err = 0;
 142
 143         if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)))
 144                 return -EFAULT;
 145
 146         switch (_NSIG_WORDS) {
 147         default:
 148                 __put_sigset_unknown_nsig();
 149         case 2:
 150                 err |= __put_user(kbuf->sig[1] >> 32, &ubuf->sig[3]);
 151                 err |= __put_user(kbuf->sig[1] & 0xffffffff, &ubuf->sig[2]);
 152         case 1:
 153                 err |= __put_user(kbuf->sig[0] >> 32, &ubuf->sig[1]);
 154                 err |= __put_user(kbuf->sig[0] & 0xffffffff, &ubuf->sig[0]);
 155         }
 156
 157         return err;
 158 }
 159
 160 static inline int get_sigset(sigset_t *kbuf, const compat_sigset_t __user *ubuf)
 161 {
 162         int err = 0;
 163         unsigned long sig[4];
 164
 165         if (!access_ok(VERIFY_READ, ubuf, sizeof(*ubuf)))
 166                 return -EFAULT;
 167
 168         switch (_NSIG_WORDS) {
 169         default:
 170                 __get_sigset_unknown_nsig();
 171         case 2:
 172                 err |= __get_user(sig[3], &ubuf->sig[3]);
 173                 err |= __get_user(sig[2], &ubuf->sig[2]);
 174                 kbuf->sig[1] = sig[2] | (sig[3] << 32);
 175         case 1:
 176                 err |= __get_user(sig[1], &ubuf->sig[1]);
 177                 err |= __get_user(sig[0], &ubuf->sig[0]);
 178                 kbuf->sig[0] = sig[0] | (sig[1] << 32);
 179         }
 180
 181         return err;
 182 }
 183
 184 /*
 185  * Atomically swap in the new signal mask, and wait for a signal.
 186  */
 187
 188 asmlinkage int sys32_sigsuspend(compat_sigset_t __user *uset)
 189 {
 190         return compat_sys_rt_sigsuspend(uset, sizeof(compat_sigset_t));
 191 }
 192
 193 SYSCALL_DEFINE3(32_sigaction, long, sig, const struct compat_sigaction __user *, act,
 194         struct compat_sigaction __user *, oact)
 195 {
 196         struct k_sigaction new_ka, old_ka;
 197         int ret;
 198         int err = 0;
 199
 200         if (act) {
 201                 old_sigset_t mask;
 202                 s32 handler;
 203
 204                 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
 205                         return -EFAULT;
 206                 err |= __get_user(handler, &act->sa_handler);
 207                 new_ka.sa.sa_handler = (void __user *)(s64)handler;
 208                 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 209                 err |= __get_user(mask, &act->sa_mask.sig[0]);
 210                 if (err)
 211                         return -EFAULT;
 212
 213                 siginitset(&new_ka.sa.sa_mask, mask);
 214         }
 215
 216         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 217
 218         if (!ret && oact) {
 219                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
 220                         return -EFAULT;
 221                 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 222                 err |= __put_user((u32)(u64)old_ka.sa.sa_handler,
 223                                   &oact->sa_handler);
 224                 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
 225                 err |= __put_user(0, &oact->sa_mask.sig[1]);
 226                 err |= __put_user(0, &oact->sa_mask.sig[2]);
 227                 err |= __put_user(0, &oact->sa_mask.sig[3]);
 228                 if (err)
 229                         return -EFAULT;
 230         }
 231
 232         return ret;
 233 }
 234
 235 int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from)
 236 {
 237         int err;
 238
 239         if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
 240                 return -EFAULT;
 241
 242         /* If you change siginfo_t structure, please be sure
 243            this code is fixed accordingly.
 244            It should never copy any pad contained in the structure
 245            to avoid security leaks, but must copy the generic
 246            3 ints plus the relevant union member.
 247            This routine must convert siginfo from 64bit to 32bit as well
 248            at the same time.  */
 249         err = __put_user(from->si_signo, &to->si_signo);
 250         err |= __put_user(from->si_errno, &to->si_errno);
 251         err |= __put_user((short)from->si_code, &to->si_code);
 252         if (from->si_code < 0)
 253                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
 254         else {
 255                 switch (from->si_code >> 16) {
 256                 case __SI_TIMER >> 16:
 257                         err |= __put_user(from->si_tid, &to->si_tid);
 258                         err |= __put_user(from->si_overrun, &to->si_overrun);
 259                         err |= __put_user(from->si_int, &to->si_int);
 260                         break;
 261                 case __SI_CHLD >> 16:
 262                         err |= __put_user(from->si_utime, &to->si_utime);
 263                         err |= __put_user(from->si_stime, &to->si_stime);
 264                         err |= __put_user(from->si_status, &to->si_status);
 265                 default:
 266                         err |= __put_user(from->si_pid, &to->si_pid);
 267                         err |= __put_user(from->si_uid, &to->si_uid);
 268                         break;
 269                 case __SI_FAULT >> 16:
 270                         err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
 271                         break;
 272                 case __SI_POLL >> 16:
 273                         err |= __put_user(from->si_band, &to->si_band);
 274                         err |= __put_user(from->si_fd, &to->si_fd);
 275                         break;
 276                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
 277                 case __SI_MESGQ >> 16:
 278                         err |= __put_user(from->si_pid, &to->si_pid);
 279                         err |= __put_user(from->si_uid, &to->si_uid);
 280                         err |= __put_user(from->si_int, &to->si_int);
 281                         break;
 282                 }
 283         }
 284         return err;
 285 }
 286
 287 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
 288 {
 289         if (copy_from_user(to, from, 3*sizeof(int)) ||
 290             copy_from_user(to->_sifields._pad,
 291                            from->_sifields._pad, SI_PAD_SIZE32))
 292                 return -EFAULT;
 293
 294         return 0;
 295 }
 296
 297 asmlinkage void sys32_sigreturn(nabi_no_regargs struct pt_regs regs)
 298 {
 299         struct sigframe32 __user *frame;
 300         sigset_t blocked;
 301         int sig;
 302
 303         frame = (struct sigframe32 __user *) regs.regs[29];
 304         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 305                 goto badframe;
 306         if (__copy_conv_sigset_from_user(&blocked, &frame->sf_mask))
 307                 goto badframe;
 308
 309         set_current_blocked(&blocked);
 310
 311         sig = restore_sigcontext32(&regs, &frame->sf_sc);
 312         if (sig < 0)
 313                 goto badframe;
 314         else if (sig)
 315                 force_sig(sig, current);
 316
 317         /*
 318          * Don't let your children do this ...
 319          */
 320         __asm__ __volatile__(
 321                 "move\t$29, %0\n\t"
 322                 "j\tsyscall_exit"
 323                 :/* no outputs */
 324                 :"r" (&regs));
 325         /* Unreached */
 326
 327 badframe:
 328         force_sig(SIGSEGV, current);
 329 }
 330
 331 asmlinkage void sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
 332 {
 333         struct rt_sigframe32 __user *frame;
 334         sigset_t set;
 335         int sig;
 336
 337         frame = (struct rt_sigframe32 __user *) regs.regs[29];
 338         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 339                 goto badframe;
 340         if (__copy_conv_sigset_from_user(&set, &frame->rs_uc.uc_sigmask))
 341                 goto badframe;
 342
 343         set_current_blocked(&set);
 344
 345         sig = restore_sigcontext32(&regs, &frame->rs_uc.uc_mcontext);
 346         if (sig < 0)
 347                 goto badframe;
 348         else if (sig)
 349                 force_sig(sig, current);
 350
 351         if (compat_restore_altstack(&frame->rs_uc.uc_stack))
 352                 goto badframe;
 353
 354         /*
 355          * Don't let your children do this ...
 356          */
 357         __asm__ __volatile__(
 358                 "move\t$29, %0\n\t"
 359                 "j\tsyscall_exit"
 360                 :/* no outputs */
 361                 :"r" (&regs));
 362         /* Unreached */
 363
 364 badframe:
 365         force_sig(SIGSEGV, current);
 366 }
 367
 368 static int setup_frame_32(void *sig_return, struct ksignal *ksig,
 369                           struct pt_regs *regs, sigset_t *set)
 370 {
 371         struct sigframe32 __user *frame;
 372         int err = 0;
 373
 374         frame = get_sigframe(ksig, regs, sizeof(*frame));
 375         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 376                 return -EFAULT;
 377
 378         err |= setup_sigcontext32(regs, &frame->sf_sc);
 379         err |= __copy_conv_sigset_to_user(&frame->sf_mask, set);
 380
 381         if (err)
 382                 return -EFAULT;
 383
 384         /*
 385          * Arguments to signal handler:
 386          *
 387          *   a0 = signal number
 388          *   a1 = 0 (should be cause)
 389          *   a2 = pointer to struct sigcontext
 390          *
 391          * $25 and c0_epc point to the signal handler, $29 points to the
 392          * struct sigframe.
 393          */
 394         regs->regs[ 4] = ksig->sig;
 395         regs->regs[ 5] = 0;
 396         regs->regs[ 6] = (unsigned long) &frame->sf_sc;
 397         regs->regs[29] = (unsigned long) frame;
 398         regs->regs[31] = (unsigned long) sig_return;
 399         regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler;
 400
 401         DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
 402                current->comm, current->pid,
 403                frame, regs->cp0_epc, regs->regs[31]);
 404
 405         return 0;
 406 }
 407
 408 static int setup_rt_frame_32(void *sig_return, struct ksignal *ksig,
 409                              struct pt_regs *regs, sigset_t *set)
 410 {
 411         struct rt_sigframe32 __user *frame;
 412         int err = 0;
 413
 414         frame = get_sigframe(ksig, regs, sizeof(*frame));
 415         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 416                 return -EFAULT;
 417
 418         /* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */
 419         err |= copy_siginfo_to_user32(&frame->rs_info, &ksig->info);
 420
 421         /* Create the ucontext.  */
 422         err |= __put_user(0, &frame->rs_uc.uc_flags);
 423         err |= __put_user(0, &frame->rs_uc.uc_link);
 424         err |= __compat_save_altstack(&frame->rs_uc.uc_stack, regs->regs[29]);
 425         err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext);
 426         err |= __copy_conv_sigset_to_user(&frame->rs_uc.uc_sigmask, set);
 427
 428         if (err)
 429                 return -EFAULT;
 430
 431         /*
 432          * Arguments to signal handler:
 433          *
 434          *   a0 = signal number
 435          *   a1 = 0 (should be cause)
 436          *   a2 = pointer to ucontext
 437          *
 438          * $25 and c0_epc point to the signal handler, $29 points to
 439          * the struct rt_sigframe32.
 440          */
 441         regs->regs[ 4] = ksig->sig;
 442         regs->regs[ 5] = (unsigned long) &frame->rs_info;
 443         regs->regs[ 6] = (unsigned long) &frame->rs_uc;
 444         regs->regs[29] = (unsigned long) frame;
 445         regs->regs[31] = (unsigned long) sig_return;
 446         regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler;
 447
 448         DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
 449                current->comm, current->pid,
 450                frame, regs->cp0_epc, regs->regs[31]);
 451
 452         return 0;
 453 }
 454
 455 /*
 456  * o32 compatibility on 64-bit kernels, without DSP ASE
 457  */
 458 struct mips_abi mips_abi_32 = {
 459         .setup_frame    = setup_frame_32,
 460         .signal_return_offset =
 461                 offsetof(struct mips_vdso, o32_signal_trampoline),
 462         .setup_rt_frame = setup_rt_frame_32,
 463         .rt_signal_return_offset =
 464                 offsetof(struct mips_vdso, o32_rt_signal_trampoline),
 465         .restart        = __NR_O32_restart_syscall,
 466
 467         .off_sc_fpregs = offsetof(struct sigcontext32, sc_fpregs),
 468         .off_sc_fpc_csr = offsetof(struct sigcontext32, sc_fpc_csr),
 469         .off_sc_used_math = offsetof(struct sigcontext32, sc_used_math),
 470 };