arch/mips/kernel/signal32.c

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