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  Ralf Baechle
   8  * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
   9  */
  10 #include <linux/cache.h>
  11 #include <linux/sched.h>
  12 #include <linux/mm.h>
  13 #include <linux/smp.h>
  14 #include <linux/smp_lock.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/compat.h>
  22 #include <linux/suspend.h>
  23 #include <linux/compiler.h>
  24
  25 #include <asm/abi.h>
  26 #include <asm/asm.h>
  27 #include <linux/bitops.h>
  28 #include <asm/cacheflush.h>
  29 #include <asm/sim.h>
  30 #include <asm/uaccess.h>
  31 #include <asm/ucontext.h>
  32 #include <asm/system.h>
  33 #include <asm/fpu.h>
  34 #include <asm/war.h>
  35
  36 #define SI_PAD_SIZE32   ((SI_MAX_SIZE/sizeof(int)) - 3)
  37
  38 typedef struct compat_siginfo {
  39         int si_signo;
  40         int si_code;
  41         int si_errno;
  42
  43         union {
  44                 int _pad[SI_PAD_SIZE32];
  45
  46                 /* kill() */
  47                 struct {
  48                         compat_pid_t _pid;      /* sender's pid */
  49                         compat_uid_t _uid;      /* sender's uid */
  50                 } _kill;
  51
  52                 /* SIGCHLD */
  53                 struct {
  54                         compat_pid_t _pid;      /* which child */
  55                         compat_uid_t _uid;      /* sender's uid */
  56                         int _status;            /* exit code */
  57                         compat_clock_t _utime;
  58                         compat_clock_t _stime;
  59                 } _sigchld;
  60
  61                 /* IRIX SIGCHLD */
  62                 struct {
  63                         compat_pid_t _pid;      /* which child */
  64                         compat_clock_t _utime;
  65                         int _status;            /* exit code */
  66                         compat_clock_t _stime;
  67                 } _irix_sigchld;
  68
  69                 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
  70                 struct {
  71                         s32 _addr; /* faulting insn/memory ref. */
  72                 } _sigfault;
  73
  74                 /* SIGPOLL, SIGXFSZ (To do ...)  */
  75                 struct {
  76                         int _band;      /* POLL_IN, POLL_OUT, POLL_MSG */
  77                         int _fd;
  78                 } _sigpoll;
  79
  80                 /* POSIX.1b timers */
  81                 struct {
  82                         timer_t _tid;           /* timer id */
  83                         int _overrun;           /* overrun count */
  84                         compat_sigval_t _sigval;/* same as below */
  85                         int _sys_private;       /* not to be passed to user */
  86                 } _timer;
  87
  88                 /* POSIX.1b signals */
  89                 struct {
  90                         compat_pid_t _pid;      /* sender's pid */
  91                         compat_uid_t _uid;      /* sender's uid */
  92                         compat_sigval_t _sigval;
  93                 } _rt;
  94
  95         } _sifields;
  96 } compat_siginfo_t;
  97
  98 /*
  99  * Including <asm/unistd.h> would give use the 64-bit syscall numbers ...
 100  */
 101 #define __NR_O32_sigreturn              4119
 102 #define __NR_O32_rt_sigreturn           4193
 103 #define __NR_O32_restart_syscall        4253
 104
 105 #define DEBUG_SIG 0
 106
 107 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
 108
 109 extern int do_signal32(sigset_t *oldset, struct pt_regs *regs);
 110
 111 /* 32-bit compatibility types */
 112
 113 #define _NSIG_BPW32     32
 114 #define _NSIG_WORDS32   (_NSIG / _NSIG_BPW32)
 115
 116 typedef struct {
 117         unsigned int sig[_NSIG_WORDS32];
 118 } sigset_t32;
 119
 120 typedef unsigned int __sighandler32_t;
 121 typedef void (*vfptr_t)(void);
 122
 123 struct sigaction32 {
 124         unsigned int            sa_flags;
 125         __sighandler32_t        sa_handler;
 126         compat_sigset_t         sa_mask;
 127 };
 128
 129 /* IRIX compatible stack_t  */
 130 typedef struct sigaltstack32 {
 131         s32 ss_sp;
 132         compat_size_t ss_size;
 133         int ss_flags;
 134 } stack32_t;
 135
 136 struct ucontext32 {
 137         u32                 uc_flags;
 138         s32                 uc_link;
 139         stack32_t           uc_stack;
 140         struct sigcontext32 uc_mcontext;
 141         sigset_t32          uc_sigmask;   /* mask last for extensibility */
 142 };
 143
 144 extern void __put_sigset_unknown_nsig(void);
 145 extern void __get_sigset_unknown_nsig(void);
 146
 147 static inline int put_sigset(const sigset_t *kbuf, compat_sigset_t __user *ubuf)
 148 {
 149         int err = 0;
 150
 151         if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)))
 152                 return -EFAULT;
 153
 154         switch (_NSIG_WORDS) {
 155         default:
 156                 __put_sigset_unknown_nsig();
 157         case 2:
 158                 err |= __put_user (kbuf->sig[1] >> 32, &ubuf->sig[3]);
 159                 err |= __put_user (kbuf->sig[1] & 0xffffffff, &ubuf->sig[2]);
 160         case 1:
 161                 err |= __put_user (kbuf->sig[0] >> 32, &ubuf->sig[1]);
 162                 err |= __put_user (kbuf->sig[0] & 0xffffffff, &ubuf->sig[0]);
 163         }
 164
 165         return err;
 166 }
 167
 168 static inline int get_sigset(sigset_t *kbuf, const compat_sigset_t *ubuf)
 169 {
 170         int err = 0;
 171         unsigned long sig[4];
 172
 173         if (!access_ok(VERIFY_READ, ubuf, sizeof(*ubuf)))
 174                 return -EFAULT;
 175
 176         switch (_NSIG_WORDS) {
 177         default:
 178                 __get_sigset_unknown_nsig();
 179         case 2:
 180                 err |= __get_user (sig[3], &ubuf->sig[3]);
 181                 err |= __get_user (sig[2], &ubuf->sig[2]);
 182                 kbuf->sig[1] = sig[2] | (sig[3] << 32);
 183         case 1:
 184                 err |= __get_user (sig[1], &ubuf->sig[1]);
 185                 err |= __get_user (sig[0], &ubuf->sig[0]);
 186                 kbuf->sig[0] = sig[0] | (sig[1] << 32);
 187         }
 188
 189         return err;
 190 }
 191
 192 /*
 193  * Atomically swap in the new signal mask, and wait for a signal.
 194  */
 195
 196 save_static_function(sys32_sigsuspend);
 197 __attribute_used__ noinline static int
 198 _sys32_sigsuspend(nabi_no_regargs struct pt_regs regs)
 199 {
 200         compat_sigset_t *uset;
 201         sigset_t newset, saveset;
 202
 203         uset = (compat_sigset_t *) regs.regs[4];
 204         if (get_sigset(&newset, uset))
 205                 return -EFAULT;
 206         sigdelsetmask(&newset, ~_BLOCKABLE);
 207
 208         spin_lock_irq(&current->sighand->siglock);
 209         saveset = current->blocked;
 210         current->blocked = newset;
 211         recalc_sigpending();
 212         spin_unlock_irq(&current->sighand->siglock);
 213
 214         regs.regs[2] = EINTR;
 215         regs.regs[7] = 1;
 216         while (1) {
 217                 current->state = TASK_INTERRUPTIBLE;
 218                 schedule();
 219                 if (do_signal32(&saveset, &regs))
 220                         return -EINTR;
 221         }
 222 }
 223
 224 save_static_function(sys32_rt_sigsuspend);
 225 __attribute_used__ noinline static int
 226 _sys32_rt_sigsuspend(nabi_no_regargs struct pt_regs regs)
 227 {
 228         compat_sigset_t *uset;
 229         sigset_t newset, saveset;
 230         size_t sigsetsize;
 231
 232         /* XXX Don't preclude handling different sized sigset_t's.  */
 233         sigsetsize = regs.regs[5];
 234         if (sigsetsize != sizeof(compat_sigset_t))
 235                 return -EINVAL;
 236
 237         uset = (compat_sigset_t *) regs.regs[4];
 238         if (get_sigset(&newset, uset))
 239                 return -EFAULT;
 240         sigdelsetmask(&newset, ~_BLOCKABLE);
 241
 242         spin_lock_irq(&current->sighand->siglock);
 243         saveset = current->blocked;
 244         current->blocked = newset;
 245         recalc_sigpending();
 246         spin_unlock_irq(&current->sighand->siglock);
 247
 248         regs.regs[2] = EINTR;
 249         regs.regs[7] = 1;
 250         while (1) {
 251                 current->state = TASK_INTERRUPTIBLE;
 252                 schedule();
 253                 if (do_signal32(&saveset, &regs))
 254                         return -EINTR;
 255         }
 256 }
 257
 258 asmlinkage int sys32_sigaction(int sig, const struct sigaction32 *act,
 259                                struct sigaction32 *oact)
 260 {
 261         struct k_sigaction new_ka, old_ka;
 262         int ret;
 263         int err = 0;
 264
 265         if (act) {
 266                 old_sigset_t mask;
 267                 s32 handler;
 268
 269                 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
 270                         return -EFAULT;
 271                 err |= __get_user(handler, &act->sa_handler);
 272                 new_ka.sa.sa_handler = (void __user *)(s64)handler;
 273                 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 274                 err |= __get_user(mask, &act->sa_mask.sig[0]);
 275                 if (err)
 276                         return -EFAULT;
 277
 278                 siginitset(&new_ka.sa.sa_mask, mask);
 279         }
 280
 281         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 282
 283         if (!ret && oact) {
 284                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
 285                         return -EFAULT;
 286                 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 287                 err |= __put_user((u32)(u64)old_ka.sa.sa_handler,
 288                                   &oact->sa_handler);
 289                 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
 290                 err |= __put_user(0, &oact->sa_mask.sig[1]);
 291                 err |= __put_user(0, &oact->sa_mask.sig[2]);
 292                 err |= __put_user(0, &oact->sa_mask.sig[3]);
 293                 if (err)
 294                         return -EFAULT;
 295         }
 296
 297         return ret;
 298 }
 299
 300 asmlinkage int sys32_sigaltstack(nabi_no_regargs struct pt_regs regs)
 301 {
 302         const stack32_t __user *uss = (const stack32_t __user *) regs.regs[4];
 303         stack32_t __user *uoss = (stack32_t __user *) regs.regs[5];
 304         unsigned long usp = regs.regs[29];
 305         stack_t kss, koss;
 306         int ret, err = 0;
 307         mm_segment_t old_fs = get_fs();
 308         s32 sp;
 309
 310         if (uss) {
 311                 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
 312                         return -EFAULT;
 313                 err |= __get_user(sp, &uss->ss_sp);
 314                 kss.ss_sp = (void *) (long) sp;
 315                 err |= __get_user(kss.ss_size, &uss->ss_size);
 316                 err |= __get_user(kss.ss_flags, &uss->ss_flags);
 317                 if (err)
 318                         return -EFAULT;
 319         }
 320
 321         set_fs (KERNEL_DS);
 322         ret = do_sigaltstack(uss ? (stack_t __user *)&kss : NULL,
 323                              uoss ? (stack_t __user *)&koss : NULL, usp);
 324         set_fs (old_fs);
 325
 326         if (!ret && uoss) {
 327                 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
 328                         return -EFAULT;
 329                 sp = (int) (long) koss.ss_sp;
 330                 err |= __put_user(sp, &uoss->ss_sp);
 331                 err |= __put_user(koss.ss_size, &uoss->ss_size);
 332                 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
 333                 if (err)
 334                         return -EFAULT;
 335         }
 336         return ret;
 337 }
 338
 339 static int restore_sigcontext32(struct pt_regs *regs, struct sigcontext32 __user *sc)
 340 {
 341         u32 used_math;
 342         int err = 0;
 343         s32 treg;
 344
 345         /* Always make any pending restarted system calls return -EINTR */
 346         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 347
 348         err |= __get_user(regs->cp0_epc, &sc->sc_pc);
 349         err |= __get_user(regs->hi, &sc->sc_mdhi);
 350         err |= __get_user(regs->lo, &sc->sc_mdlo);
 351         if (cpu_has_dsp) {
 352                 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
 353                 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
 354                 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
 355                 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
 356                 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
 357                 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
 358                 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
 359         }
 360
 361 #define restore_gp_reg(i) do {                                          \
 362         err |= __get_user(regs->regs[i], &sc->sc_regs[i]);              \
 363 } while(0)
 364         restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
 365         restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
 366         restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
 367         restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
 368         restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
 369         restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
 370         restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
 371         restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
 372         restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
 373         restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
 374         restore_gp_reg(31);
 375 #undef restore_gp_reg
 376
 377         err |= __get_user(used_math, &sc->sc_used_math);
 378         conditional_used_math(used_math);
 379
 380         preempt_disable();
 381
 382         if (used_math()) {
 383                 /* restore fpu context if we have used it before */
 384                 own_fpu();
 385                 err |= restore_fp_context32(sc);
 386         } else {
 387                 /* signal handler may have used FPU.  Give it up. */
 388                 lose_fpu();
 389         }
 390
 391         preempt_enable();
 392
 393         return err;
 394 }
 395
 396 struct sigframe {
 397         u32 sf_ass[4];                  /* argument save space for o32 */
 398 #if ICACHE_REFILLS_WORKAROUND_WAR
 399         u32 sf_pad[2];
 400 #else
 401         u32 sf_code[2];                 /* signal trampoline */
 402 #endif
 403         struct sigcontext32 sf_sc;
 404         sigset_t sf_mask;
 405 #if ICACHE_REFILLS_WORKAROUND_WAR
 406         u32 sf_code[8] ____cacheline_aligned;   /* signal trampoline */
 407 #endif
 408 };
 409
 410 struct rt_sigframe32 {
 411         u32 rs_ass[4];                  /* argument save space for o32 */
 412 #if ICACHE_REFILLS_WORKAROUND_WAR
 413         u32 rs_pad[2];
 414 #else
 415         u32 rs_code[2];                 /* signal trampoline */
 416 #endif
 417         compat_siginfo_t rs_info;
 418         struct ucontext32 rs_uc;
 419 #if ICACHE_REFILLS_WORKAROUND_WAR
 420         u32 rs_code[8] __attribute__((aligned(32)));    /* signal trampoline */
 421 #endif
 422 };
 423
 424 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
 425 {
 426         int err;
 427
 428         if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
 429                 return -EFAULT;
 430
 431         /* If you change siginfo_t structure, please be sure
 432            this code is fixed accordingly.
 433            It should never copy any pad contained in the structure
 434            to avoid security leaks, but must copy the generic
 435            3 ints plus the relevant union member.
 436            This routine must convert siginfo from 64bit to 32bit as well
 437            at the same time.  */
 438         err = __put_user(from->si_signo, &to->si_signo);
 439         err |= __put_user(from->si_errno, &to->si_errno);
 440         err |= __put_user((short)from->si_code, &to->si_code);
 441         if (from->si_code < 0)
 442                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
 443         else {
 444                 switch (from->si_code >> 16) {
 445                 case __SI_TIMER >> 16:
 446                         err |= __put_user(from->si_tid, &to->si_tid);
 447                         err |= __put_user(from->si_overrun, &to->si_overrun);
 448                         err |= __put_user(from->si_int, &to->si_int);
 449                         break;
 450                 case __SI_CHLD >> 16:
 451                         err |= __put_user(from->si_utime, &to->si_utime);
 452                         err |= __put_user(from->si_stime, &to->si_stime);
 453                         err |= __put_user(from->si_status, &to->si_status);
 454                 default:
 455                         err |= __put_user(from->si_pid, &to->si_pid);
 456                         err |= __put_user(from->si_uid, &to->si_uid);
 457                         break;
 458                 case __SI_FAULT >> 16:
 459                         err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
 460                         break;
 461                 case __SI_POLL >> 16:
 462                         err |= __put_user(from->si_band, &to->si_band);
 463                         err |= __put_user(from->si_fd, &to->si_fd);
 464                         break;
 465                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
 466                 case __SI_MESGQ >> 16:
 467                         err |= __put_user(from->si_pid, &to->si_pid);
 468                         err |= __put_user(from->si_uid, &to->si_uid);
 469                         err |= __put_user(from->si_int, &to->si_int);
 470                         break;
 471                 }
 472         }
 473         return err;
 474 }
 475
 476 save_static_function(sys32_sigreturn);
 477 __attribute_used__ noinline static void
 478 _sys32_sigreturn(nabi_no_regargs struct pt_regs regs)
 479 {
 480         struct sigframe __user *frame;
 481         sigset_t blocked;
 482
 483         frame = (struct sigframe __user *) regs.regs[29];
 484         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 485                 goto badframe;
 486         if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
 487                 goto badframe;
 488
 489         sigdelsetmask(&blocked, ~_BLOCKABLE);
 490         spin_lock_irq(&current->sighand->siglock);
 491         current->blocked = blocked;
 492         recalc_sigpending();
 493         spin_unlock_irq(&current->sighand->siglock);
 494
 495         if (restore_sigcontext32(&regs, &frame->sf_sc))
 496                 goto badframe;
 497
 498         /*
 499          * Don't let your children do this ...
 500          */
 501         __asm__ __volatile__(
 502                 "move\t$29, %0\n\t"
 503                 "j\tsyscall_exit"
 504                 :/* no outputs */
 505                 :"r" (&regs));
 506         /* Unreached */
 507
 508 badframe:
 509         force_sig(SIGSEGV, current);
 510 }
 511
 512 save_static_function(sys32_rt_sigreturn);
 513 __attribute_used__ noinline static void
 514 _sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
 515 {
 516         struct rt_sigframe32 __user *frame;
 517         mm_segment_t old_fs;
 518         sigset_t set;
 519         stack_t st;
 520         s32 sp;
 521
 522         frame = (struct rt_sigframe32 __user *) regs.regs[29];
 523         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 524                 goto badframe;
 525         if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
 526                 goto badframe;
 527
 528         sigdelsetmask(&set, ~_BLOCKABLE);
 529         spin_lock_irq(&current->sighand->siglock);
 530         current->blocked = set;
 531         recalc_sigpending();
 532         spin_unlock_irq(&current->sighand->siglock);
 533
 534         if (restore_sigcontext32(&regs, &frame->rs_uc.uc_mcontext))
 535                 goto badframe;
 536
 537         /* The ucontext contains a stack32_t, so we must convert!  */
 538         if (__get_user(sp, &frame->rs_uc.uc_stack.ss_sp))
 539                 goto badframe;
 540         st.ss_size = (long) sp;
 541         if (__get_user(st.ss_size, &frame->rs_uc.uc_stack.ss_size))
 542                 goto badframe;
 543         if (__get_user(st.ss_flags, &frame->rs_uc.uc_stack.ss_flags))
 544                 goto badframe;
 545
 546         /* It is more difficult to avoid calling this function than to
 547            call it and ignore errors.  */
 548         old_fs = get_fs();
 549         set_fs (KERNEL_DS);
 550         do_sigaltstack((stack_t __user *)&st, NULL, regs.regs[29]);
 551         set_fs (old_fs);
 552
 553         /*
 554          * Don't let your children do this ...
 555          */
 556         __asm__ __volatile__(
 557                 "move\t$29, %0\n\t"
 558                 "j\tsyscall_exit"
 559                 :/* no outputs */
 560                 :"r" (&regs));
 561         /* Unreached */
 562
 563 badframe:
 564         force_sig(SIGSEGV, current);
 565 }
 566
 567 static inline int setup_sigcontext32(struct pt_regs *regs,
 568                                      struct sigcontext32 __user *sc)
 569 {
 570         int err = 0;
 571
 572         err |= __put_user(regs->cp0_epc, &sc->sc_pc);
 573         err |= __put_user(regs->cp0_status, &sc->sc_status);
 574
 575 #define save_gp_reg(i) {                                                \
 576         err |= __put_user(regs->regs[i], &sc->sc_regs[i]);              \
 577 } while(0)
 578         __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
 579         save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
 580         save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
 581         save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
 582         save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
 583         save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
 584         save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
 585         save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
 586         save_gp_reg(31);
 587 #undef save_gp_reg
 588
 589         err |= __put_user(regs->hi, &sc->sc_mdhi);
 590         err |= __put_user(regs->lo, &sc->sc_mdlo);
 591         if (cpu_has_dsp) {
 592                 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
 593                 err |= __put_user(mfhi1(), &sc->sc_hi1);
 594                 err |= __put_user(mflo1(), &sc->sc_lo1);
 595                 err |= __put_user(mfhi2(), &sc->sc_hi2);
 596                 err |= __put_user(mflo2(), &sc->sc_lo2);
 597                 err |= __put_user(mfhi3(), &sc->sc_hi3);
 598                 err |= __put_user(mflo3(), &sc->sc_lo3);
 599         }
 600
 601         err |= __put_user(!!used_math(), &sc->sc_used_math);
 602
 603         if (!used_math())
 604                 goto out;
 605
 606         /*
 607          * Save FPU state to signal context.  Signal handler will "inherit"
 608          * current FPU state.
 609          */
 610         preempt_disable();
 611
 612         if (!is_fpu_owner()) {
 613                 own_fpu();
 614                 restore_fp(current);
 615         }
 616         err |= save_fp_context32(sc);
 617
 618         preempt_enable();
 619
 620 out:
 621         return err;
 622 }
 623
 624 /*
 625  * Determine which stack to use..
 626  */
 627 static inline void __user *get_sigframe(struct k_sigaction *ka,
 628                                         struct pt_regs *regs,
 629                                         size_t frame_size)
 630 {
 631         unsigned long sp;
 632
 633         /* Default to using normal stack */
 634         sp = regs->regs[29];
 635
 636         /*
 637          * FPU emulator may have it's own trampoline active just
 638          * above the user stack, 16-bytes before the next lowest
 639          * 16 byte boundary.  Try to avoid trashing it.
 640          */
 641         sp -= 32;
 642
 643         /* This is the X/Open sanctioned signal stack switching.  */
 644         if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags (sp) == 0))
 645                 sp = current->sas_ss_sp + current->sas_ss_size;
 646
 647         return (void __user *)((sp - frame_size) & ALMASK);
 648 }
 649
 650 int setup_frame_32(struct k_sigaction * ka, struct pt_regs *regs,
 651         int signr, sigset_t *set)
 652 {
 653         struct sigframe __user *frame;
 654         int err = 0;
 655
 656         frame = get_sigframe(ka, regs, sizeof(*frame));
 657         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 658                 goto give_sigsegv;
 659
 660         /*
 661          * Set up the return code ...
 662          *
 663          *         li      v0, __NR_O32_sigreturn
 664          *         syscall
 665          */
 666         err |= __put_user(0x24020000 + __NR_O32_sigreturn, frame->sf_code + 0);
 667         err |= __put_user(0x0000000c                     , frame->sf_code + 1);
 668         flush_cache_sigtramp((unsigned long) frame->sf_code);
 669
 670         err |= setup_sigcontext32(regs, &frame->sf_sc);
 671         err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
 672         if (err)
 673                 goto give_sigsegv;
 674
 675         /*
 676          * Arguments to signal handler:
 677          *
 678          *   a0 = signal number
 679          *   a1 = 0 (should be cause)
 680          *   a2 = pointer to struct sigcontext
 681          *
 682          * $25 and c0_epc point to the signal handler, $29 points to the
 683          * struct sigframe.
 684          */
 685         regs->regs[ 4] = signr;
 686         regs->regs[ 5] = 0;
 687         regs->regs[ 6] = (unsigned long) &frame->sf_sc;
 688         regs->regs[29] = (unsigned long) frame;
 689         regs->regs[31] = (unsigned long) frame->sf_code;
 690         regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
 691
 692 #if DEBUG_SIG
 693         printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n",
 694                current->comm, current->pid,
 695                frame, regs->cp0_epc, frame->sf_code);
 696 #endif
 697         return 1;
 698
 699 give_sigsegv:
 700         force_sigsegv(signr, current);
 701         return 0;
 702 }
 703
 704 int setup_rt_frame_32(struct k_sigaction * ka, struct pt_regs *regs,
 705         int signr, sigset_t *set, siginfo_t *info)
 706 {
 707         struct rt_sigframe32 __user *frame;
 708         int err = 0;
 709         s32 sp;
 710
 711         frame = get_sigframe(ka, regs, sizeof(*frame));
 712         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 713                 goto give_sigsegv;
 714
 715         /* Set up to return from userspace.  If provided, use a stub already
 716            in userspace.  */
 717         /*
 718          * Set up the return code ...
 719          *
 720          *         li      v0, __NR_O32_rt_sigreturn
 721          *         syscall
 722          */
 723         err |= __put_user(0x24020000 + __NR_O32_rt_sigreturn, frame->rs_code + 0);
 724         err |= __put_user(0x0000000c                      , frame->rs_code + 1);
 725         flush_cache_sigtramp((unsigned long) frame->rs_code);
 726
 727         /* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */
 728         err |= copy_siginfo_to_user32(&frame->rs_info, info);
 729
 730         /* Create the ucontext.  */
 731         err |= __put_user(0, &frame->rs_uc.uc_flags);
 732         err |= __put_user(0, &frame->rs_uc.uc_link);
 733         sp = (int) (long) current->sas_ss_sp;
 734         err |= __put_user(sp,
 735                           &frame->rs_uc.uc_stack.ss_sp);
 736         err |= __put_user(sas_ss_flags(regs->regs[29]),
 737                           &frame->rs_uc.uc_stack.ss_flags);
 738         err |= __put_user(current->sas_ss_size,
 739                           &frame->rs_uc.uc_stack.ss_size);
 740         err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext);
 741         err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
 742
 743         if (err)
 744                 goto give_sigsegv;
 745
 746         /*
 747          * Arguments to signal handler:
 748          *
 749          *   a0 = signal number
 750          *   a1 = 0 (should be cause)
 751          *   a2 = pointer to ucontext
 752          *
 753          * $25 and c0_epc point to the signal handler, $29 points to
 754          * the struct rt_sigframe32.
 755          */
 756         regs->regs[ 4] = signr;
 757         regs->regs[ 5] = (unsigned long) &frame->rs_info;
 758         regs->regs[ 6] = (unsigned long) &frame->rs_uc;
 759         regs->regs[29] = (unsigned long) frame;
 760         regs->regs[31] = (unsigned long) frame->rs_code;
 761         regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
 762
 763 #if DEBUG_SIG
 764         printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n",
 765                current->comm, current->pid,
 766                frame, regs->cp0_epc, frame->rs_code);
 767 #endif
 768         return 1;
 769
 770 give_sigsegv:
 771         force_sigsegv(signr, current);
 772         return 0;
 773 }
 774
 775 static inline int handle_signal(unsigned long sig, siginfo_t *info,
 776         struct k_sigaction *ka, sigset_t *oldset, struct pt_regs * regs)
 777 {
 778         int ret;
 779
 780         switch (regs->regs[0]) {
 781         case ERESTART_RESTARTBLOCK:
 782         case ERESTARTNOHAND:
 783                 regs->regs[2] = EINTR;
 784                 break;
 785         case ERESTARTSYS:
 786                 if(!(ka->sa.sa_flags & SA_RESTART)) {
 787                         regs->regs[2] = EINTR;
 788                         break;
 789                 }
 790         /* fallthrough */
 791         case ERESTARTNOINTR:            /* Userland will reload $v0.  */
 792                 regs->regs[7] = regs->regs[26];
 793                 regs->cp0_epc -= 8;
 794         }
 795
 796         regs->regs[0] = 0;              /* Don't deal with this again.  */
 797
 798         if (ka->sa.sa_flags & SA_SIGINFO)
 799                 ret = current->thread.abi->setup_rt_frame(ka, regs, sig, oldset, info);
 800         else
 801                 ret = current->thread.abi->setup_frame(ka, regs, sig, oldset);
 802
 803         spin_lock_irq(&current->sighand->siglock);
 804         sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 805         if (!(ka->sa.sa_flags & SA_NODEFER))
 806                 sigaddset(&current->blocked,sig);
 807         recalc_sigpending();
 808         spin_unlock_irq(&current->sighand->siglock);
 809
 810         return ret;
 811 }
 812
 813 int do_signal32(sigset_t *oldset, struct pt_regs *regs)
 814 {
 815         struct k_sigaction ka;
 816         siginfo_t info;
 817         int signr;
 818
 819         /*
 820          * We want the common case to go fast, which is why we may in certain
 821          * cases get here from kernel mode. Just return without doing anything
 822          * if so.
 823          */
 824         if (!user_mode(regs))
 825                 return 1;
 826
 827         if (try_to_freeze())
 828                 goto no_signal;
 829
 830         if (!oldset)
 831                 oldset = &current->blocked;
 832
 833         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 834         if (signr > 0)
 835                 return handle_signal(signr, &info, &ka, oldset, regs);
 836
 837 no_signal:
 838         /*
 839          * Who's code doesn't conform to the restartable syscall convention
 840          * dies here!!!  The li instruction, a single machine instruction,
 841          * must directly be followed by the syscall instruction.
 842          */
 843         if (regs->regs[0]) {
 844                 if (regs->regs[2] == ERESTARTNOHAND ||
 845                     regs->regs[2] == ERESTARTSYS ||
 846                     regs->regs[2] == ERESTARTNOINTR) {
 847                         regs->regs[7] = regs->regs[26];
 848                         regs->cp0_epc -= 8;
 849                 }
 850                 if (regs->regs[2] == ERESTART_RESTARTBLOCK) {
 851                         regs->regs[2] = __NR_O32_restart_syscall;
 852                         regs->regs[7] = regs->regs[26];
 853                         regs->cp0_epc -= 4;
 854                 }
 855         }
 856         return 0;
 857 }
 858
 859 asmlinkage int sys32_rt_sigaction(int sig, const struct sigaction32 *act,
 860                                   struct sigaction32 __user *oact,
 861                                   unsigned int sigsetsize)
 862 {
 863         struct k_sigaction new_sa, old_sa;
 864         int ret = -EINVAL;
 865
 866         /* XXX: Don't preclude handling different sized sigset_t's.  */
 867         if (sigsetsize != sizeof(sigset_t))
 868                 goto out;
 869
 870         if (act) {
 871                 s32 handler;
 872                 int err = 0;
 873
 874                 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
 875                         return -EFAULT;
 876                 err |= __get_user(handler, &act->sa_handler);
 877                 new_sa.sa.sa_handler = (void __user *)(s64)handler;
 878                 err |= __get_user(new_sa.sa.sa_flags, &act->sa_flags);
 879                 err |= get_sigset(&new_sa.sa.sa_mask, &act->sa_mask);
 880                 if (err)
 881                         return -EFAULT;
 882         }
 883
 884         ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
 885
 886         if (!ret && oact) {
 887                 int err = 0;
 888
 889                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
 890                         return -EFAULT;
 891
 892                 err |= __put_user((u32)(u64)old_sa.sa.sa_handler,
 893                                    &oact->sa_handler);
 894                 err |= __put_user(old_sa.sa.sa_flags, &oact->sa_flags);
 895                 err |= put_sigset(&old_sa.sa.sa_mask, &oact->sa_mask);
 896                 if (err)
 897                         return -EFAULT;
 898         }
 899 out:
 900         return ret;
 901 }
 902
 903 asmlinkage int sys32_rt_sigprocmask(int how, compat_sigset_t *set,
 904         compat_sigset_t __user *oset, unsigned int sigsetsize)
 905 {
 906         sigset_t old_set, new_set;
 907         int ret;
 908         mm_segment_t old_fs = get_fs();
 909
 910         if (set && get_sigset(&new_set, set))
 911                 return -EFAULT;
 912
 913         set_fs (KERNEL_DS);
 914         ret = sys_rt_sigprocmask(how, set ? (sigset_t __user *)&new_set : NULL,
 915                                  oset ? (sigset_t __user *)&old_set : NULL,
 916                                  sigsetsize);
 917         set_fs (old_fs);
 918
 919         if (!ret && oset && put_sigset(&old_set, oset))
 920                 return -EFAULT;
 921
 922         return ret;
 923 }
 924
 925 asmlinkage int sys32_rt_sigpending(compat_sigset_t __user *uset,
 926         unsigned int sigsetsize)
 927 {
 928         int ret;
 929         sigset_t set;
 930         mm_segment_t old_fs = get_fs();
 931
 932         set_fs (KERNEL_DS);
 933         ret = sys_rt_sigpending((sigset_t __user *)&set, sigsetsize);
 934         set_fs (old_fs);
 935
 936         if (!ret && put_sigset(&set, uset))
 937                 return -EFAULT;
 938
 939         return ret;
 940 }
 941
 942 asmlinkage int sys32_rt_sigqueueinfo(int pid, int sig, compat_siginfo_t __user *uinfo)
 943 {
 944         siginfo_t info;
 945         int ret;
 946         mm_segment_t old_fs = get_fs();
 947
 948         if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
 949             copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE))
 950                 return -EFAULT;
 951         set_fs (KERNEL_DS);
 952         ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *)&info);
 953         set_fs (old_fs);
 954         return ret;
 955 }
 956
 957 asmlinkage long
 958 sys32_waitid(int which, compat_pid_t pid,
 959              compat_siginfo_t __user *uinfo, int options,
 960              struct compat_rusage __user *uru)
 961 {
 962         siginfo_t info;
 963         struct rusage ru;
 964         long ret;
 965         mm_segment_t old_fs = get_fs();
 966
 967         info.si_signo = 0;
 968         set_fs (KERNEL_DS);
 969         ret = sys_waitid(which, pid, (siginfo_t __user *) &info, options,
 970                          uru ? (struct rusage __user *) &ru : NULL);
 971         set_fs (old_fs);
 972
 973         if (ret < 0 || info.si_signo == 0)
 974                 return ret;
 975
 976         if (uru && (ret = put_compat_rusage(&ru, uru)))
 977                 return ret;
 978
 979         BUG_ON(info.si_code & __SI_MASK);
 980         info.si_code |= __SI_CHLD;
 981         return copy_siginfo_to_user32(uinfo, &info);
 982 }