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