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/asm.h>
  25 #include <linux/bitops.h>
  26 #include <asm/cacheflush.h>
  27 #include <asm/sim.h>
  28 #include <asm/uaccess.h>
  29 #include <asm/ucontext.h>
  30 #include <asm/system.h>
  31 #include <asm/fpu.h>
  32
  33 #define SI_PAD_SIZE32   ((SI_MAX_SIZE/sizeof(int)) - 3)
  34
  35 typedef union sigval32 {
  36         int sival_int;
  37         s32 sival_ptr;
  38 } sigval_t32;
  39
  40 typedef struct siginfo32 {
  41         int si_signo;
  42         int si_code;
  43         int si_errno;
  44
  45         union {
  46                 int _pad[SI_PAD_SIZE32];
  47
  48                 /* kill() */
  49                 struct {
  50                         compat_pid_t _pid;      /* sender's pid */
  51                         compat_uid_t _uid;      /* sender's uid */
  52                 } _kill;
  53
  54                 /* SIGCHLD */
  55                 struct {
  56                         compat_pid_t _pid;      /* which child */
  57                         compat_uid_t _uid;      /* sender's uid */
  58                         int _status;            /* exit code */
  59                         compat_clock_t _utime;
  60                         compat_clock_t _stime;
  61                 } _sigchld;
  62
  63                 /* IRIX SIGCHLD */
  64                 struct {
  65                         compat_pid_t _pid;      /* which child */
  66                         compat_clock_t _utime;
  67                         int _status;            /* exit code */
  68                         compat_clock_t _stime;
  69                 } _irix_sigchld;
  70
  71                 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
  72                 struct {
  73                         s32 _addr; /* faulting insn/memory ref. */
  74                 } _sigfault;
  75
  76                 /* SIGPOLL, SIGXFSZ (To do ...)  */
  77                 struct {
  78                         int _band;      /* POLL_IN, POLL_OUT, POLL_MSG */
  79                         int _fd;
  80                 } _sigpoll;
  81
  82                 /* POSIX.1b timers */
  83                 struct {
  84                         unsigned int _timer1;
  85                         unsigned int _timer2;
  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                         sigval_t32 _sigval;
  93                 } _rt;
  94
  95         } _sifields;
  96 } siginfo_t32;
  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 asmlinkage 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 *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 save_static_function(sys32_sigsuspend);
 196 __attribute_used__ noinline static int
 197 _sys32_sigsuspend(nabi_no_regargs struct pt_regs regs)
 198 {
 199         compat_sigset_t *uset;
 200         sigset_t newset, saveset;
 201
 202         uset = (compat_sigset_t *) regs.regs[4];
 203         if (get_sigset(&newset, uset))
 204                 return -EFAULT;
 205         sigdelsetmask(&newset, ~_BLOCKABLE);
 206
 207         spin_lock_irq(&current->sighand->siglock);
 208         saveset = current->blocked;
 209         current->blocked = newset;
 210         recalc_sigpending();
 211         spin_unlock_irq(&current->sighand->siglock);
 212
 213         regs.regs[2] = EINTR;
 214         regs.regs[7] = 1;
 215         while (1) {
 216                 current->state = TASK_INTERRUPTIBLE;
 217                 schedule();
 218                 if (do_signal32(&saveset, &regs))
 219                         return -EINTR;
 220         }
 221 }
 222
 223 save_static_function(sys32_rt_sigsuspend);
 224 __attribute_used__ noinline static int
 225 _sys32_rt_sigsuspend(nabi_no_regargs struct pt_regs regs)
 226 {
 227         compat_sigset_t *uset;
 228         sigset_t newset, saveset;
 229         size_t sigsetsize;
 230
 231         /* XXX Don't preclude handling different sized sigset_t's.  */
 232         sigsetsize = regs.regs[5];
 233         if (sigsetsize != sizeof(compat_sigset_t))
 234                 return -EINVAL;
 235
 236         uset = (compat_sigset_t *) regs.regs[4];
 237         if (get_sigset(&newset, uset))
 238                 return -EFAULT;
 239         sigdelsetmask(&newset, ~_BLOCKABLE);
 240
 241         spin_lock_irq(&current->sighand->siglock);
 242         saveset = current->blocked;
 243         current->blocked = newset;
 244         recalc_sigpending();
 245         spin_unlock_irq(&current->sighand->siglock);
 246
 247         regs.regs[2] = EINTR;
 248         regs.regs[7] = 1;
 249         while (1) {
 250                 current->state = TASK_INTERRUPTIBLE;
 251                 schedule();
 252                 if (do_signal32(&saveset, &regs))
 253                         return -EINTR;
 254         }
 255 }
 256
 257 asmlinkage int sys32_sigaction(int sig, const struct sigaction32 *act,
 258                                struct sigaction32 *oact)
 259 {
 260         struct k_sigaction new_ka, old_ka;
 261         int ret;
 262         int err = 0;
 263
 264         if (act) {
 265                 old_sigset_t mask;
 266
 267                 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
 268                         return -EFAULT;
 269                 err |= __get_user((u32)(u64)new_ka.sa.sa_handler,
 270                                   &act->sa_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 asmlinkage int restore_sigcontext32(struct pt_regs *regs,
 337                                            struct sigcontext32 *sc)
 338 {
 339         int err = 0;
 340
 341         /* Always make any pending restarted system calls return -EINTR */
 342         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 343
 344         err |= __get_user(regs->cp0_epc, &sc->sc_pc);
 345         err |= __get_user(regs->hi, &sc->sc_mdhi);
 346         err |= __get_user(regs->lo, &sc->sc_mdlo);
 347
 348 #define restore_gp_reg(i) do {                                          \
 349         err |= __get_user(regs->regs[i], &sc->sc_regs[i]);              \
 350 } while(0)
 351         restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
 352         restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
 353         restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
 354         restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
 355         restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
 356         restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
 357         restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
 358         restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
 359         restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
 360         restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
 361         restore_gp_reg(31);
 362 #undef restore_gp_reg
 363
 364         err |= __get_user(current->used_math, &sc->sc_used_math);
 365
 366         preempt_disable();
 367
 368         if (current->used_math) {
 369                 /* restore fpu context if we have used it before */
 370                 own_fpu();
 371                 err |= restore_fp_context32(sc);
 372         } else {
 373                 /* signal handler may have used FPU.  Give it up. */
 374                 lose_fpu();
 375         }
 376
 377         preempt_enable();
 378
 379         return err;
 380 }
 381
 382 struct sigframe {
 383         u32 sf_ass[4];                  /* argument save space for o32 */
 384         u32 sf_code[2];                 /* signal trampoline */
 385         struct sigcontext32 sf_sc;
 386         sigset_t sf_mask;
 387 };
 388
 389 struct rt_sigframe32 {
 390         u32 rs_ass[4];                  /* argument save space for o32 */
 391         u32 rs_code[2];                 /* signal trampoline */
 392         struct siginfo32 rs_info;
 393         struct ucontext32 rs_uc;
 394 };
 395
 396 static int copy_siginfo_to_user32(siginfo_t32 *to, siginfo_t *from)
 397 {
 398         int err;
 399
 400         if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t32)))
 401                 return -EFAULT;
 402
 403         /* If you change siginfo_t structure, please be sure
 404            this code is fixed accordingly.
 405            It should never copy any pad contained in the structure
 406            to avoid security leaks, but must copy the generic
 407            3 ints plus the relevant union member.
 408            This routine must convert siginfo from 64bit to 32bit as well
 409            at the same time.  */
 410         err = __put_user(from->si_signo, &to->si_signo);
 411         err |= __put_user(from->si_errno, &to->si_errno);
 412         err |= __put_user((short)from->si_code, &to->si_code);
 413         if (from->si_code < 0)
 414                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
 415         else {
 416                 switch (from->si_code >> 16) {
 417                 case __SI_CHLD >> 16:
 418                         err |= __put_user(from->si_utime, &to->si_utime);
 419                         err |= __put_user(from->si_stime, &to->si_stime);
 420                         err |= __put_user(from->si_status, &to->si_status);
 421                 default:
 422                         err |= __put_user(from->si_pid, &to->si_pid);
 423                         err |= __put_user(from->si_uid, &to->si_uid);
 424                         break;
 425                 case __SI_FAULT >> 16:
 426                         err |= __put_user((long)from->si_addr, &to->si_addr);
 427                         break;
 428                 case __SI_POLL >> 16:
 429                         err |= __put_user(from->si_band, &to->si_band);
 430                         err |= __put_user(from->si_fd, &to->si_fd);
 431                         break;
 432                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
 433                 case __SI_MESGQ >> 16:
 434                         err |= __put_user(from->si_pid, &to->si_pid);
 435                         err |= __put_user(from->si_uid, &to->si_uid);
 436                         err |= __put_user(from->si_int, &to->si_int);
 437                         break;
 438                 }
 439         }
 440         return err;
 441 }
 442
 443 asmlinkage void sys32_sigreturn(nabi_no_regargs struct pt_regs regs)
 444 {
 445         struct sigframe *frame;
 446         sigset_t blocked;
 447
 448         frame = (struct sigframe *) regs.regs[29];
 449         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 450                 goto badframe;
 451         if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
 452                 goto badframe;
 453
 454         sigdelsetmask(&blocked, ~_BLOCKABLE);
 455         spin_lock_irq(&current->sighand->siglock);
 456         current->blocked = blocked;
 457         recalc_sigpending();
 458         spin_unlock_irq(&current->sighand->siglock);
 459
 460         if (restore_sigcontext32(&regs, &frame->sf_sc))
 461                 goto badframe;
 462
 463         /*
 464          * Don't let your children do this ...
 465          */
 466         if (current_thread_info()->flags & TIF_SYSCALL_TRACE)
 467                 do_syscall_trace(&regs, 1);
 468         __asm__ __volatile__(
 469                 "move\t$29, %0\n\t"
 470                 "j\tsyscall_exit"
 471                 :/* no outputs */
 472                 :"r" (&regs));
 473         /* Unreached */
 474
 475 badframe:
 476         force_sig(SIGSEGV, current);
 477 }
 478
 479 asmlinkage void sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
 480 {
 481         struct rt_sigframe32 *frame;
 482         sigset_t set;
 483         stack_t st;
 484         s32 sp;
 485
 486         frame = (struct rt_sigframe32 *) regs.regs[29];
 487         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 488                 goto badframe;
 489         if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
 490                 goto badframe;
 491
 492         sigdelsetmask(&set, ~_BLOCKABLE);
 493         spin_lock_irq(&current->sighand->siglock);
 494         current->blocked = set;
 495         recalc_sigpending();
 496         spin_unlock_irq(&current->sighand->siglock);
 497
 498         if (restore_sigcontext32(&regs, &frame->rs_uc.uc_mcontext))
 499                 goto badframe;
 500
 501         /* The ucontext contains a stack32_t, so we must convert!  */
 502         if (__get_user(sp, &frame->rs_uc.uc_stack.ss_sp))
 503                 goto badframe;
 504         st.ss_size = (long) sp;
 505         if (__get_user(st.ss_size, &frame->rs_uc.uc_stack.ss_size))
 506                 goto badframe;
 507         if (__get_user(st.ss_flags, &frame->rs_uc.uc_stack.ss_flags))
 508                 goto badframe;
 509
 510         /* It is more difficult to avoid calling this function than to
 511            call it and ignore errors.  */
 512         do_sigaltstack(&st, NULL, regs.regs[29]);
 513
 514         /*
 515          * Don't let your children do this ...
 516          */
 517         __asm__ __volatile__(
 518                 "move\t$29, %0\n\t"
 519                 "j\tsyscall_exit"
 520                 :/* no outputs */
 521                 :"r" (&regs));
 522         /* Unreached */
 523
 524 badframe:
 525         force_sig(SIGSEGV, current);
 526 }
 527
 528 static inline int setup_sigcontext32(struct pt_regs *regs,
 529                                      struct sigcontext32 *sc)
 530 {
 531         int err = 0;
 532
 533         err |= __put_user(regs->cp0_epc, &sc->sc_pc);
 534         err |= __put_user(regs->cp0_status, &sc->sc_status);
 535
 536 #define save_gp_reg(i) {                                                \
 537         err |= __put_user(regs->regs[i], &sc->sc_regs[i]);              \
 538 } while(0)
 539         __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
 540         save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
 541         save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
 542         save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
 543         save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
 544         save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
 545         save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
 546         save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
 547         save_gp_reg(31);
 548 #undef save_gp_reg
 549
 550         err |= __put_user(regs->hi, &sc->sc_mdhi);
 551         err |= __put_user(regs->lo, &sc->sc_mdlo);
 552         err |= __put_user(regs->cp0_cause, &sc->sc_cause);
 553         err |= __put_user(regs->cp0_badvaddr, &sc->sc_badvaddr);
 554
 555         err |= __put_user(current->used_math, &sc->sc_used_math);
 556
 557         if (!current->used_math)
 558                 goto out;
 559
 560         /*
 561          * Save FPU state to signal context.  Signal handler will "inherit"
 562          * current FPU state.
 563          */
 564         preempt_disable();
 565
 566         if (!is_fpu_owner()) {
 567                 own_fpu();
 568                 restore_fp(current);
 569         }
 570         err |= save_fp_context32(sc);
 571
 572         preempt_enable();
 573
 574 out:
 575         return err;
 576 }
 577
 578 /*
 579  * Determine which stack to use..
 580  */
 581 static inline void *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
 582                                  size_t frame_size)
 583 {
 584         unsigned long sp;
 585
 586         /* Default to using normal stack */
 587         sp = regs->regs[29];
 588
 589         /*
 590          * FPU emulator may have it's own trampoline active just
 591          * above the user stack, 16-bytes before the next lowest
 592          * 16 byte boundary.  Try to avoid trashing it.
 593          */
 594         sp -= 32;
 595
 596         /* This is the X/Open sanctioned signal stack switching.  */
 597         if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags (sp) == 0))
 598                 sp = current->sas_ss_sp + current->sas_ss_size;
 599
 600         return (void *)((sp - frame_size) & ALMASK);
 601 }
 602
 603 static inline void setup_frame(struct k_sigaction * ka, struct pt_regs *regs,
 604                                int signr, sigset_t *set)
 605 {
 606         struct sigframe *frame;
 607         int err = 0;
 608
 609         frame = get_sigframe(ka, regs, sizeof(*frame));
 610         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 611                 goto give_sigsegv;
 612
 613         /*
 614          * Set up the return code ...
 615          *
 616          *         li      v0, __NR_O32_sigreturn
 617          *         syscall
 618          */
 619         err |= __put_user(0x24020000 + __NR_O32_sigreturn, frame->sf_code + 0);
 620         err |= __put_user(0x0000000c                     , frame->sf_code + 1);
 621         flush_cache_sigtramp((unsigned long) frame->sf_code);
 622
 623         err |= setup_sigcontext32(regs, &frame->sf_sc);
 624         err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
 625         if (err)
 626                 goto give_sigsegv;
 627
 628         /*
 629          * Arguments to signal handler:
 630          *
 631          *   a0 = signal number
 632          *   a1 = 0 (should be cause)
 633          *   a2 = pointer to struct sigcontext
 634          *
 635          * $25 and c0_epc point to the signal handler, $29 points to the
 636          * struct sigframe.
 637          */
 638         regs->regs[ 4] = signr;
 639         regs->regs[ 5] = 0;
 640         regs->regs[ 6] = (unsigned long) &frame->sf_sc;
 641         regs->regs[29] = (unsigned long) frame;
 642         regs->regs[31] = (unsigned long) frame->sf_code;
 643         regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
 644
 645 #if DEBUG_SIG
 646         printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n",
 647                current->comm, current->pid,
 648                frame, regs->cp0_epc, frame->sf_code);
 649 #endif
 650         return;
 651
 652 give_sigsegv:
 653         force_sigsegv(signr, current);
 654 }
 655
 656 static inline void setup_rt_frame(struct k_sigaction * ka,
 657                                   struct pt_regs *regs, int signr,
 658                                   sigset_t *set, siginfo_t *info)
 659 {
 660         struct rt_sigframe32 *frame;
 661         int err = 0;
 662         s32 sp;
 663
 664         frame = get_sigframe(ka, regs, sizeof(*frame));
 665         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 666                 goto give_sigsegv;
 667
 668         /* Set up to return from userspace.  If provided, use a stub already
 669            in userspace.  */
 670         /*
 671          * Set up the return code ...
 672          *
 673          *         li      v0, __NR_O32_rt_sigreturn
 674          *         syscall
 675          */
 676         err |= __put_user(0x24020000 + __NR_O32_rt_sigreturn, frame->rs_code + 0);
 677         err |= __put_user(0x0000000c                      , frame->rs_code + 1);
 678         flush_cache_sigtramp((unsigned long) frame->rs_code);
 679
 680         /* Convert (siginfo_t -> siginfo_t32) and copy to user. */
 681         err |= copy_siginfo_to_user32(&frame->rs_info, info);
 682
 683         /* Create the ucontext.  */
 684         err |= __put_user(0, &frame->rs_uc.uc_flags);
 685         err |= __put_user(0, &frame->rs_uc.uc_link);
 686         sp = (int) (long) current->sas_ss_sp;
 687         err |= __put_user(sp,
 688                           &frame->rs_uc.uc_stack.ss_sp);
 689         err |= __put_user(sas_ss_flags(regs->regs[29]),
 690                           &frame->rs_uc.uc_stack.ss_flags);
 691         err |= __put_user(current->sas_ss_size,
 692                           &frame->rs_uc.uc_stack.ss_size);
 693         err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext);
 694         err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
 695
 696         if (err)
 697                 goto give_sigsegv;
 698
 699         /*
 700          * Arguments to signal handler:
 701          *
 702          *   a0 = signal number
 703          *   a1 = 0 (should be cause)
 704          *   a2 = pointer to ucontext
 705          *
 706          * $25 and c0_epc point to the signal handler, $29 points to
 707          * the struct rt_sigframe32.
 708          */
 709         regs->regs[ 4] = signr;
 710         regs->regs[ 5] = (unsigned long) &frame->rs_info;
 711         regs->regs[ 6] = (unsigned long) &frame->rs_uc;
 712         regs->regs[29] = (unsigned long) frame;
 713         regs->regs[31] = (unsigned long) frame->rs_code;
 714         regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
 715
 716 #if DEBUG_SIG
 717         printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n",
 718                current->comm, current->pid,
 719                frame, regs->cp0_epc, frame->rs_code);
 720 #endif
 721         return;
 722
 723 give_sigsegv:
 724         force_sigsegv(signr, current);
 725 }
 726
 727 static inline void handle_signal(unsigned long sig, siginfo_t *info,
 728         struct k_sigaction *ka, sigset_t *oldset, struct pt_regs * regs)
 729 {
 730         switch (regs->regs[0]) {
 731         case ERESTART_RESTARTBLOCK:
 732         case ERESTARTNOHAND:
 733                 regs->regs[2] = EINTR;
 734                 break;
 735         case ERESTARTSYS:
 736                 if(!(ka->sa.sa_flags & SA_RESTART)) {
 737                         regs->regs[2] = EINTR;
 738                         break;
 739                 }
 740         /* fallthrough */
 741         case ERESTARTNOINTR:            /* Userland will reload $v0.  */
 742                 regs->regs[7] = regs->regs[26];
 743                 regs->cp0_epc -= 8;
 744         }
 745
 746         regs->regs[0] = 0;              /* Don't deal with this again.  */
 747
 748         if (ka->sa.sa_flags & SA_SIGINFO)
 749                 setup_rt_frame(ka, regs, sig, oldset, info);
 750         else
 751                 setup_frame(ka, regs, sig, oldset);
 752
 753         if (!(ka->sa.sa_flags & SA_NODEFER)) {
 754                 spin_lock_irq(&current->sighand->siglock);
 755                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 756                 sigaddset(&current->blocked,sig);
 757                 recalc_sigpending();
 758                 spin_unlock_irq(&current->sighand->siglock);
 759         }
 760 }
 761
 762 asmlinkage int do_signal32(sigset_t *oldset, struct pt_regs *regs)
 763 {
 764         struct k_sigaction ka;
 765         siginfo_t info;
 766         int signr;
 767
 768         /*
 769          * We want the common case to go fast, which is why we may in certain
 770          * cases get here from kernel mode. Just return without doing anything
 771          * if so.
 772          */
 773         if (!user_mode(regs))
 774                 return 1;
 775
 776         if (current->flags & PF_FREEZE) {
 777                 refrigerator(0);
 778                 goto no_signal;
 779         }
 780
 781         if (!oldset)
 782                 oldset = &current->blocked;
 783
 784         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 785         if (signr > 0) {
 786                 handle_signal(signr, &info, &ka, oldset, regs);
 787                 return 1;
 788         }
 789
 790 no_signal:
 791         /*
 792          * Who's code doesn't conform to the restartable syscall convention
 793          * dies here!!!  The li instruction, a single machine instruction,
 794          * must directly be followed by the syscall instruction.
 795          */
 796         if (regs->regs[0]) {
 797                 if (regs->regs[2] == ERESTARTNOHAND ||
 798                     regs->regs[2] == ERESTARTSYS ||
 799                     regs->regs[2] == ERESTARTNOINTR) {
 800                         regs->regs[7] = regs->regs[26];
 801                         regs->cp0_epc -= 8;
 802                 }
 803                 if (regs->regs[2] == ERESTART_RESTARTBLOCK) {
 804                         regs->regs[2] = __NR_O32_restart_syscall;
 805                         regs->regs[7] = regs->regs[26];
 806                         regs->cp0_epc -= 4;
 807                 }
 808         }
 809         return 0;
 810 }
 811
 812 asmlinkage int sys32_rt_sigaction(int sig, const struct sigaction32 *act,
 813                                   struct sigaction32 *oact,
 814                                   unsigned int sigsetsize)
 815 {
 816         struct k_sigaction new_sa, old_sa;
 817         int ret = -EINVAL;
 818
 819         /* XXX: Don't preclude handling different sized sigset_t's.  */
 820         if (sigsetsize != sizeof(sigset_t))
 821                 goto out;
 822
 823         if (act) {
 824                 int err = 0;
 825
 826                 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
 827                         return -EFAULT;
 828                 err |= __get_user((u32)(u64)new_sa.sa.sa_handler,
 829                                   &act->sa_handler);
 830                 err |= __get_user(new_sa.sa.sa_flags, &act->sa_flags);
 831                 err |= get_sigset(&new_sa.sa.sa_mask, &act->sa_mask);
 832                 if (err)
 833                         return -EFAULT;
 834         }
 835
 836         ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
 837
 838         if (!ret && oact) {
 839                 int err = 0;
 840
 841                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
 842                         return -EFAULT;
 843
 844                 err |= __put_user((u32)(u64)old_sa.sa.sa_handler,
 845                                    &oact->sa_handler);
 846                 err |= __put_user(old_sa.sa.sa_flags, &oact->sa_flags);
 847                 err |= put_sigset(&old_sa.sa.sa_mask, &oact->sa_mask);
 848                 if (err)
 849                         return -EFAULT;
 850         }
 851 out:
 852         return ret;
 853 }
 854
 855 asmlinkage int sys32_rt_sigprocmask(int how, compat_sigset_t *set,
 856         compat_sigset_t *oset, unsigned int sigsetsize)
 857 {
 858         sigset_t old_set, new_set;
 859         int ret;
 860         mm_segment_t old_fs = get_fs();
 861
 862         if (set && get_sigset(&new_set, set))
 863                 return -EFAULT;
 864
 865         set_fs (KERNEL_DS);
 866         ret = sys_rt_sigprocmask(how, set ? &new_set : NULL,
 867                                  oset ? &old_set : NULL, sigsetsize);
 868         set_fs (old_fs);
 869
 870         if (!ret && oset && put_sigset(&old_set, oset))
 871                 return -EFAULT;
 872
 873         return ret;
 874 }
 875
 876 asmlinkage int sys32_rt_sigpending(compat_sigset_t *uset,
 877         unsigned int sigsetsize)
 878 {
 879         int ret;
 880         sigset_t set;
 881         mm_segment_t old_fs = get_fs();
 882
 883         set_fs (KERNEL_DS);
 884         ret = sys_rt_sigpending(&set, sigsetsize);
 885         set_fs (old_fs);
 886
 887         if (!ret && put_sigset(&set, uset))
 888                 return -EFAULT;
 889
 890         return ret;
 891 }
 892
 893 asmlinkage int sys32_rt_sigtimedwait(compat_sigset_t *uthese,
 894         siginfo_t32 *uinfo, struct compat_timespec *uts,
 895         compat_time_t sigsetsize)
 896 {
 897         int ret, sig;
 898         sigset_t these;
 899         compat_sigset_t these32;
 900         struct timespec ts;
 901         siginfo_t info;
 902         long timeout = 0;
 903
 904         /*
 905          * As the result of a brainfarting competition a few years ago the
 906          * size of sigset_t for the 32-bit kernel was choosen to be 128 bits
 907          * but nothing so far is actually using that many, 64 are enough.  So
 908          * for now we just drop the high bits.
 909          */
 910         if (copy_from_user (&these32, uthese, sizeof(compat_old_sigset_t)))
 911                 return -EFAULT;
 912
 913         switch (_NSIG_WORDS) {
 914 #ifdef __MIPSEB__
 915         case 4: these.sig[3] = these32.sig[6] | (((long)these32.sig[7]) << 32);
 916         case 3: these.sig[2] = these32.sig[4] | (((long)these32.sig[5]) << 32);
 917         case 2: these.sig[1] = these32.sig[2] | (((long)these32.sig[3]) << 32);
 918         case 1: these.sig[0] = these32.sig[0] | (((long)these32.sig[1]) << 32);
 919 #endif
 920 #ifdef __MIPSEL__
 921         case 4: these.sig[3] = these32.sig[7] | (((long)these32.sig[6]) << 32);
 922         case 3: these.sig[2] = these32.sig[5] | (((long)these32.sig[4]) << 32);
 923         case 2: these.sig[1] = these32.sig[3] | (((long)these32.sig[2]) << 32);
 924         case 1: these.sig[0] = these32.sig[1] | (((long)these32.sig[0]) << 32);
 925 #endif
 926         }
 927
 928         /*
 929          * Invert the set of allowed signals to get those we
 930          * want to block.
 931          */
 932         sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
 933         signotset(&these);
 934
 935         if (uts) {
 936                 if (get_user (ts.tv_sec, &uts->tv_sec) ||
 937                     get_user (ts.tv_nsec, &uts->tv_nsec))
 938                         return -EINVAL;
 939                 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
 940                     || ts.tv_sec < 0)
 941                         return -EINVAL;
 942         }
 943
 944         spin_lock_irq(&current->sighand->siglock);
 945         sig = dequeue_signal(current, &these, &info);
 946         if (!sig) {
 947                 /* None ready -- temporarily unblock those we're interested
 948                    in so that we'll be awakened when they arrive.  */
 949                 sigset_t oldblocked = current->blocked;
 950                 sigandsets(&current->blocked, &current->blocked, &these);
 951                 recalc_sigpending();
 952                 spin_unlock_irq(&current->sighand->siglock);
 953
 954                 timeout = MAX_SCHEDULE_TIMEOUT;
 955                 if (uts)
 956                         timeout = (timespec_to_jiffies(&ts)
 957                                    + (ts.tv_sec || ts.tv_nsec));
 958
 959                 current->state = TASK_INTERRUPTIBLE;
 960                 timeout = schedule_timeout(timeout);
 961
 962                 spin_lock_irq(&current->sighand->siglock);
 963                 sig = dequeue_signal(current, &these, &info);
 964                 current->blocked = oldblocked;
 965                 recalc_sigpending();
 966         }
 967         spin_unlock_irq(&current->sighand->siglock);
 968
 969         if (sig) {
 970                 ret = sig;
 971                 if (uinfo) {
 972                         if (copy_siginfo_to_user32(uinfo, &info))
 973                                 ret = -EFAULT;
 974                 }
 975         } else {
 976                 ret = -EAGAIN;
 977                 if (timeout)
 978                         ret = -EINTR;
 979         }
 980
 981         return ret;
 982 }
 983
 984 asmlinkage int sys32_rt_sigqueueinfo(int pid, int sig, siginfo_t32 *uinfo)
 985 {
 986         siginfo_t info;
 987         int ret;
 988         mm_segment_t old_fs = get_fs();
 989
 990         if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
 991             copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE))
 992                 return -EFAULT;
 993         set_fs (KERNEL_DS);
 994         ret = sys_rt_sigqueueinfo(pid, sig, &info);
 995         set_fs (old_fs);
 996         return ret;
 997 }