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