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