arch/mips/kernel/signal32.c

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  *
   6  * Copyright (C) 1991, 1992  Linus Torvalds
   7  * Copyright (C) 1994 - 2000  Ralf Baechle
   8  * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
   9  */
  10 #include <linux/sched.h>
  11 #include <linux/mm.h>
  12 #include <linux/smp.h>
  13 #include <linux/smp_lock.h>
  14 #include <linux/kernel.h>
  15 #include <linux/signal.h>
  16 #include <linux/syscalls.h>
  17 #include <linux/errno.h>
  18 #include <linux/wait.h>
  19 #include <linux/ptrace.h>
  20 #include <linux/compat.h>
  21 #include <linux/suspend.h>
  22
  23 #include <asm/asm.h>
  24 #include <asm/bitops.h>
  25 #include <asm/cacheflush.h>
  26 #include <asm/sim.h>
  27 #include <asm/uaccess.h>
  28 #include <asm/ucontext.h>
  29 #include <asm/system.h>
  30 #include <asm/fpu.h>
  31
  32 /*
  33  * Including <asm/unistd.h> would give use the 64-bit syscall numbers ...
  34  */
  35 #define __NR_O32_sigreturn              4119
  36 #define __NR_O32_rt_sigreturn           4193
  37 #define __NR_O32_restart_syscall        4253
  38
  39 #define DEBUG_SIG 0
  40
  41 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  42
  43 extern asmlinkage int do_signal32(sigset_t *oldset, struct pt_regs *regs);
  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(&regs, 1);
 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         force_sigsegv(signr, current);
 578 }
 579
 580 static inline void setup_rt_frame(struct k_sigaction * ka,
 581                                   struct pt_regs *regs, int signr,
 582                                   sigset_t *set, siginfo_t *info)
 583 {
 584         struct rt_sigframe32 *frame;
 585         int err = 0;
 586         s32 sp;
 587
 588         frame = get_sigframe(ka, regs, sizeof(*frame));
 589         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 590                 goto give_sigsegv;
 591
 592         /* Set up to return from userspace.  If provided, use a stub already
 593            in userspace.  */
 594         /*
 595          * Set up the return code ...
 596          *
 597          *         li      v0, __NR_O32_rt_sigreturn
 598          *         syscall
 599          */
 600         err |= __put_user(0x24020000 + __NR_O32_rt_sigreturn, frame->rs_code + 0);
 601         err |= __put_user(0x0000000c                      , frame->rs_code + 1);
 602         flush_cache_sigtramp((unsigned long) frame->rs_code);
 603
 604         /* Convert (siginfo_t -> siginfo_t32) and copy to user. */
 605         err |= copy_siginfo_to_user32(&frame->rs_info, info);
 606
 607         /* Create the ucontext.  */
 608         err |= __put_user(0, &frame->rs_uc.uc_flags);
 609         err |= __put_user(0, &frame->rs_uc.uc_link);
 610         sp = (int) (long) current->sas_ss_sp;
 611         err |= __put_user(sp,
 612                           &frame->rs_uc.uc_stack.ss_sp);
 613         err |= __put_user(sas_ss_flags(regs->regs[29]),
 614                           &frame->rs_uc.uc_stack.ss_flags);
 615         err |= __put_user(current->sas_ss_size,
 616                           &frame->rs_uc.uc_stack.ss_size);
 617         err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext);
 618         err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
 619
 620         if (err)
 621                 goto give_sigsegv;
 622
 623         /*
 624          * Arguments to signal handler:
 625          *
 626          *   a0 = signal number
 627          *   a1 = 0 (should be cause)
 628          *   a2 = pointer to ucontext
 629          *
 630          * $25 and c0_epc point to the signal handler, $29 points to
 631          * the struct rt_sigframe32.
 632          */
 633         regs->regs[ 4] = signr;
 634         regs->regs[ 5] = (unsigned long) &frame->rs_info;
 635         regs->regs[ 6] = (unsigned long) &frame->rs_uc;
 636         regs->regs[29] = (unsigned long) frame;
 637         regs->regs[31] = (unsigned long) frame->rs_code;
 638         regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
 639
 640 #if DEBUG_SIG
 641         printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n",
 642                current->comm, current->pid,
 643                frame, regs->cp0_epc, frame->rs_code);
 644 #endif
 645         return;
 646
 647 give_sigsegv:
 648         force_sigsegv(signr, current);
 649 }
 650
 651 static inline void handle_signal(unsigned long sig, siginfo_t *info,
 652         sigset_t *oldset, struct pt_regs * regs)
 653 {
 654         struct k_sigaction *ka = &current->sighand->action[sig-1];
 655
 656         switch (regs->regs[0]) {
 657         case ERESTART_RESTARTBLOCK:
 658         case ERESTARTNOHAND:
 659                 regs->regs[2] = EINTR;
 660                 break;
 661         case ERESTARTSYS:
 662                 if(!(ka->sa.sa_flags & SA_RESTART)) {
 663                         regs->regs[2] = EINTR;
 664                         break;
 665                 }
 666         /* fallthrough */
 667         case ERESTARTNOINTR:            /* Userland will reload $v0.  */
 668                 regs->regs[7] = regs->regs[26];
 669                 regs->cp0_epc -= 8;
 670         }
 671
 672         regs->regs[0] = 0;              /* Don't deal with this again.  */
 673
 674         if (ka->sa.sa_flags & SA_SIGINFO)
 675                 setup_rt_frame(ka, regs, sig, oldset, info);
 676         else
 677                 setup_frame(ka, regs, sig, oldset);
 678
 679         if (ka->sa.sa_flags & SA_ONESHOT)
 680                 ka->sa.sa_handler = SIG_DFL;
 681         if (!(ka->sa.sa_flags & SA_NODEFER)) {
 682                 spin_lock_irq(&current->sighand->siglock);
 683                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 684                 sigaddset(&current->blocked,sig);
 685                 recalc_sigpending();
 686                 spin_unlock_irq(&current->sighand->siglock);
 687         }
 688 }
 689
 690 asmlinkage int do_signal32(sigset_t *oldset, struct pt_regs *regs)
 691 {
 692         siginfo_t info;
 693         int signr;
 694
 695         /*
 696          * We want the common case to go fast, which is why we may in certain
 697          * cases get here from kernel mode. Just return without doing anything
 698          * if so.
 699          */
 700         if (!user_mode(regs))
 701                 return 1;
 702
 703         if (current->flags & PF_FREEZE) {
 704                 refrigerator(0);
 705                 goto no_signal;
 706         }
 707
 708         if (!oldset)
 709                 oldset = &current->blocked;
 710
 711         signr = get_signal_to_deliver(&info, regs, NULL);
 712         if (signr > 0) {
 713                 handle_signal(signr, &info, oldset, regs);
 714                 return 1;
 715         }
 716
 717 no_signal:
 718         /*
 719          * Who's code doesn't conform to the restartable syscall convention
 720          * dies here!!!  The li instruction, a single machine instruction,
 721          * must directly be followed by the syscall instruction.
 722          */
 723         if (regs->regs[0]) {
 724                 if (regs->regs[2] == ERESTARTNOHAND ||
 725                     regs->regs[2] == ERESTARTSYS ||
 726                     regs->regs[2] == ERESTARTNOINTR) {
 727                         regs->regs[7] = regs->regs[26];
 728                         regs->cp0_epc -= 8;
 729                 }
 730                 if (regs->regs[2] == ERESTART_RESTARTBLOCK) {
 731                         regs->regs[2] = __NR_O32_restart_syscall;
 732                         regs->regs[7] = regs->regs[26];
 733                         regs->cp0_epc -= 4;
 734                 }
 735         }
 736         return 0;
 737 }
 738
 739 asmlinkage int sys32_rt_sigaction(int sig, const struct sigaction32 *act,
 740                                   struct sigaction32 *oact,
 741                                   unsigned int sigsetsize)
 742 {
 743         struct k_sigaction new_sa, old_sa;
 744         int ret = -EINVAL;
 745
 746         /* XXX: Don't preclude handling different sized sigset_t's.  */
 747         if (sigsetsize != sizeof(sigset_t))
 748                 goto out;
 749
 750         if (act) {
 751                 int err = 0;
 752
 753                 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
 754                         return -EFAULT;
 755                 err |= __get_user((u32)(u64)new_sa.sa.sa_handler,
 756                                   &act->sa_handler);
 757                 err |= __get_user(new_sa.sa.sa_flags, &act->sa_flags);
 758                 err |= get_sigset(&new_sa.sa.sa_mask, &act->sa_mask);
 759                 if (err)
 760                         return -EFAULT;
 761         }
 762
 763         ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
 764
 765         if (!ret && oact) {
 766                 int err = 0;
 767
 768                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
 769                         return -EFAULT;
 770
 771                 err |= __put_user((u32)(u64)old_sa.sa.sa_handler,
 772                                    &oact->sa_handler);
 773                 err |= __put_user(old_sa.sa.sa_flags, &oact->sa_flags);
 774                 err |= put_sigset(&old_sa.sa.sa_mask, &oact->sa_mask);
 775                 if (err)
 776                         return -EFAULT;
 777         }
 778 out:
 779         return ret;
 780 }
 781
 782 asmlinkage int sys32_rt_sigprocmask(int how, compat_sigset_t *set,
 783         compat_sigset_t *oset, unsigned int sigsetsize)
 784 {
 785         sigset_t old_set, new_set;
 786         int ret;
 787         mm_segment_t old_fs = get_fs();
 788
 789         if (set && get_sigset(&new_set, set))
 790                 return -EFAULT;
 791
 792         set_fs (KERNEL_DS);
 793         ret = sys_rt_sigprocmask(how, set ? &new_set : NULL,
 794                                  oset ? &old_set : NULL, sigsetsize);
 795         set_fs (old_fs);
 796
 797         if (!ret && oset && put_sigset(&old_set, oset))
 798                 return -EFAULT;
 799
 800         return ret;
 801 }
 802
 803 asmlinkage int sys32_rt_sigpending(compat_sigset_t *uset,
 804         unsigned int sigsetsize)
 805 {
 806         int ret;
 807         sigset_t set;
 808         mm_segment_t old_fs = get_fs();
 809
 810         set_fs (KERNEL_DS);
 811         ret = sys_rt_sigpending(&set, sigsetsize);
 812         set_fs (old_fs);
 813
 814         if (!ret && put_sigset(&set, uset))
 815                 return -EFAULT;
 816
 817         return ret;
 818 }
 819
 820 asmlinkage int sys32_rt_sigtimedwait(compat_sigset_t *uthese,
 821         siginfo_t32 *uinfo, struct compat_timespec *uts,
 822         compat_time_t sigsetsize)
 823 {
 824         int ret, sig;
 825         sigset_t these;
 826         compat_sigset_t these32;
 827         struct timespec ts;
 828         siginfo_t info;
 829         long timeout = 0;
 830
 831         /*
 832          * As the result of a brainfarting competition a few years ago the
 833          * size of sigset_t for the 32-bit kernel was choosen to be 128 bits
 834          * but nothing so far is actually using that many, 64 are enough.  So
 835          * for now we just drop the high bits.
 836          */
 837         if (copy_from_user (&these32, uthese, sizeof(compat_old_sigset_t)))
 838                 return -EFAULT;
 839
 840         switch (_NSIG_WORDS) {
 841 #ifdef __MIPSEB__
 842         case 4: these.sig[3] = these32.sig[6] | (((long)these32.sig[7]) << 32);
 843         case 3: these.sig[2] = these32.sig[4] | (((long)these32.sig[5]) << 32);
 844         case 2: these.sig[1] = these32.sig[2] | (((long)these32.sig[3]) << 32);
 845         case 1: these.sig[0] = these32.sig[0] | (((long)these32.sig[1]) << 32);
 846 #endif
 847 #ifdef __MIPSEL__
 848         case 4: these.sig[3] = these32.sig[7] | (((long)these32.sig[6]) << 32);
 849         case 3: these.sig[2] = these32.sig[5] | (((long)these32.sig[4]) << 32);
 850         case 2: these.sig[1] = these32.sig[3] | (((long)these32.sig[2]) << 32);
 851         case 1: these.sig[0] = these32.sig[1] | (((long)these32.sig[0]) << 32);
 852 #endif
 853         }
 854
 855         /*
 856          * Invert the set of allowed signals to get those we
 857          * want to block.
 858          */
 859         sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
 860         signotset(&these);
 861
 862         if (uts) {
 863                 if (get_user (ts.tv_sec, &uts->tv_sec) ||
 864                     get_user (ts.tv_nsec, &uts->tv_nsec))
 865                         return -EINVAL;
 866                 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
 867                     || ts.tv_sec < 0)
 868                         return -EINVAL;
 869         }
 870
 871         spin_lock_irq(&current->sighand->siglock);
 872         sig = dequeue_signal(current, &these, &info);
 873         if (!sig) {
 874                 /* None ready -- temporarily unblock those we're interested
 875                    in so that we'll be awakened when they arrive.  */
 876                 sigset_t oldblocked = current->blocked;
 877                 sigandsets(&current->blocked, &current->blocked, &these);
 878                 recalc_sigpending();
 879                 spin_unlock_irq(&current->sighand->siglock);
 880
 881                 timeout = MAX_SCHEDULE_TIMEOUT;
 882                 if (uts)
 883                         timeout = (timespec_to_jiffies(&ts)
 884                                    + (ts.tv_sec || ts.tv_nsec));
 885
 886                 current->state = TASK_INTERRUPTIBLE;
 887                 timeout = schedule_timeout(timeout);
 888
 889                 spin_lock_irq(&current->sighand->siglock);
 890                 sig = dequeue_signal(current, &these, &info);
 891                 current->blocked = oldblocked;
 892                 recalc_sigpending();
 893         }
 894         spin_unlock_irq(&current->sighand->siglock);
 895
 896         if (sig) {
 897                 ret = sig;
 898                 if (uinfo) {
 899                         if (copy_siginfo_to_user32(uinfo, &info))
 900                                 ret = -EFAULT;
 901                 }
 902         } else {
 903                 ret = -EAGAIN;
 904                 if (timeout)
 905                         ret = -EINTR;
 906         }
 907
 908         return ret;
 909 }
 910
 911 asmlinkage int sys32_rt_sigqueueinfo(int pid, int sig, siginfo_t32 *uinfo)
 912 {
 913         siginfo_t info;
 914         int ret;
 915         mm_segment_t old_fs = get_fs();
 916
 917         if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
 918             copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE))
 919                 return -EFAULT;
 920         set_fs (KERNEL_DS);
 921         ret = sys_rt_sigqueueinfo(pid, sig, &info);
 922         set_fs (old_fs);
 923         return ret;
 924 }