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