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