LXR linux/arch/alpha/kernel/signal.c

   1/*
   2 *  linux/arch/alpha/kernel/signal.c
   3 *
   4 *  Copyright (C) 1995  Linus Torvalds
   5 *
   6 *  1997-11-02  Modified for POSIX.1b signals by Richard Henderson
   7 */
   8
   9#include <linux/sched.h>
  10#include <linux/kernel.h>
  11#include <linux/signal.h>
  12#include <linux/errno.h>
  13#include <linux/wait.h>
  14#include <linux/ptrace.h>
  15#include <linux/unistd.h>
  16#include <linux/mm.h>
  17#include <linux/smp.h>
  18#include <linux/stddef.h>
  19#include <linux/tty.h>
  20#include <linux/binfmts.h>
  21#include <linux/bitops.h>
  22#include <linux/syscalls.h>
  23#include <linux/tracehook.h>
  24
  25#include <asm/uaccess.h>
  26#include <asm/sigcontext.h>
  27#include <asm/ucontext.h>
  28
  29#include "proto.h"
  30
  31
  32#define DEBUG_SIG 0
  33
  34#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  35
  36asmlinkage void ret_from_sys_call(void);
  37static void do_signal(struct pt_regs *, struct switch_stack *,
  38                      unsigned long, unsigned long);
  39
  40
  41/*
  42 * The OSF/1 sigprocmask calling sequence is different from the
  43 * C sigprocmask() sequence..
  44 *
  45 * how:
  46 * 1 - SIG_BLOCK
  47 * 2 - SIG_UNBLOCK
  48 * 3 - SIG_SETMASK
  49 *
  50 * We change the range to -1 .. 1 in order to let gcc easily
  51 * use the conditional move instructions.
  52 *
  53 * Note that we don't need to acquire the kernel lock for SMP
  54 * operation, as all of this is local to this thread.
  55 */
  56SYSCALL_DEFINE3(osf_sigprocmask, int, how, unsigned long, newmask,
  57                struct pt_regs *, regs)
  58{
  59        unsigned long oldmask = -EINVAL;
  60
  61        if ((unsigned long)how-1 <= 2) {
  62                long sign = how-2;              /* -1 .. 1 */
  63                unsigned long block, unblock;
  64
  65                newmask &= _BLOCKABLE;
  66                spin_lock_irq(&current->sighand->siglock);
  67                oldmask = current->blocked.sig[0];
  68
  69                unblock = oldmask & ~newmask;
  70                block = oldmask | newmask;
  71                if (!sign)
  72                        block = unblock;
  73                if (sign <= 0)
  74                        newmask = block;
  75                if (_NSIG_WORDS > 1 && sign > 0)
  76                        sigemptyset(&current->blocked);
  77                current->blocked.sig[0] = newmask;
  78                recalc_sigpending();
  79                spin_unlock_irq(&current->sighand->siglock);
  80
  81                regs->r0 = 0;           /* special no error return */
  82        }
  83        return oldmask;
  84}
  85
  86SYSCALL_DEFINE3(osf_sigaction, int, sig,
  87                const struct osf_sigaction __user *, act,
  88                struct osf_sigaction __user *, oact)
  89{
  90        struct k_sigaction new_ka, old_ka;
  91        int ret;
  92
  93        if (act) {
  94                old_sigset_t mask;
  95                if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
  96                    __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
  97                    __get_user(new_ka.sa.sa_flags, &act->sa_flags))
  98                        return -EFAULT;
  99                __get_user(mask, &act->sa_mask);
 100                siginitset(&new_ka.sa.sa_mask, mask);
 101                new_ka.ka_restorer = NULL;
 102        }
 103
 104        ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 105
 106        if (!ret && oact) {
 107                if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
 108                    __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
 109                    __put_user(old_ka.sa.sa_flags, &oact->sa_flags))
 110                        return -EFAULT;
 111                __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
 112        }
 113
 114        return ret;
 115}
 116
 117SYSCALL_DEFINE5(rt_sigaction, int, sig, const struct sigaction __user *, act,
 118                struct sigaction __user *, oact,
 119                size_t, sigsetsize, void __user *, restorer)
 120{
 121        struct k_sigaction new_ka, old_ka;
 122        int ret;
 123
 124        /* XXX: Don't preclude handling different sized sigset_t's.  */
 125        if (sigsetsize != sizeof(sigset_t))
 126                return -EINVAL;
 127
 128        if (act) {
 129                new_ka.ka_restorer = restorer;
 130                if (copy_from_user(&new_ka.sa, act, sizeof(*act)))
 131                        return -EFAULT;
 132        }
 133
 134        ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 135
 136        if (!ret && oact) {
 137                if (copy_to_user(oact, &old_ka.sa, sizeof(*oact)))
 138                        return -EFAULT;
 139        }
 140
 141        return ret;
 142}
 143
 144/*
 145 * Atomically swap in the new signal mask, and wait for a signal.
 146 */
 147asmlinkage int
 148do_sigsuspend(old_sigset_t mask, struct pt_regs *regs, struct switch_stack *sw)
 149{
 150        mask &= _BLOCKABLE;
 151        spin_lock_irq(&current->sighand->siglock);
 152        current->saved_sigmask = current->blocked;
 153        siginitset(&current->blocked, mask);
 154        recalc_sigpending();
 155        spin_unlock_irq(&current->sighand->siglock);
 156
 157        /* Indicate EINTR on return from any possible signal handler,
 158           which will not come back through here, but via sigreturn.  */
 159        regs->r0 = EINTR;
 160        regs->r19 = 1;
 161
 162        current->state = TASK_INTERRUPTIBLE;
 163        schedule();
 164        set_thread_flag(TIF_RESTORE_SIGMASK);
 165        return -ERESTARTNOHAND;
 166}
 167
 168asmlinkage int
 169do_rt_sigsuspend(sigset_t __user *uset, size_t sigsetsize,
 170                 struct pt_regs *regs, struct switch_stack *sw)
 171{
 172        sigset_t set;
 173
 174        /* XXX: Don't preclude handling different sized sigset_t's.  */
 175        if (sigsetsize != sizeof(sigset_t))
 176                return -EINVAL;
 177        if (copy_from_user(&set, uset, sizeof(set)))
 178                return -EFAULT;
 179
 180        sigdelsetmask(&set, ~_BLOCKABLE);
 181        spin_lock_irq(&current->sighand->siglock);
 182        current->saved_sigmask = current->blocked;
 183        current->blocked = set;
 184        recalc_sigpending();
 185        spin_unlock_irq(&current->sighand->siglock);
 186
 187        /* Indicate EINTR on return from any possible signal handler,
 188           which will not come back through here, but via sigreturn.  */
 189        regs->r0 = EINTR;
 190        regs->r19 = 1;
 191
 192        current->state = TASK_INTERRUPTIBLE;
 193        schedule();
 194        set_thread_flag(TIF_RESTORE_SIGMASK);
 195        return -ERESTARTNOHAND;
 196}
 197
 198asmlinkage int
 199sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
 200{
 201        return do_sigaltstack(uss, uoss, rdusp());
 202}
 203
 204/*
 205 * Do a signal return; undo the signal stack.
 206 */
 207
 208#if _NSIG_WORDS > 1
 209# error "Non SA_SIGINFO frame needs rearranging"
 210#endif
 211
 212struct sigframe
 213{
 214        struct sigcontext sc;
 215        unsigned int retcode[3];
 216};
 217
 218struct rt_sigframe
 219{
 220        struct siginfo info;
 221        struct ucontext uc;
 222        unsigned int retcode[3];
 223};
 224
 225/* If this changes, userland unwinders that Know Things about our signal
 226   frame will break.  Do not undertake lightly.  It also implies an ABI
 227   change wrt the size of siginfo_t, which may cause some pain.  */
 228extern char compile_time_assert
 229        [offsetof(struct rt_sigframe, uc.uc_mcontext) == 176 ? 1 : -1];
 230
 231#define INSN_MOV_R30_R16        0x47fe0410
 232#define INSN_LDI_R0             0x201f0000
 233#define INSN_CALLSYS            0x00000083
 234
 235static long
 236restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
 237                   struct switch_stack *sw)
 238{
 239        unsigned long usp;
 240        long i, err = __get_user(regs->pc, &sc->sc_pc);
 241
 242        sw->r26 = (unsigned long) ret_from_sys_call;
 243
 244        err |= __get_user(regs->r0, sc->sc_regs+0);
 245        err |= __get_user(regs->r1, sc->sc_regs+1);
 246        err |= __get_user(regs->r2, sc->sc_regs+2);
 247        err |= __get_user(regs->r3, sc->sc_regs+3);
 248        err |= __get_user(regs->r4, sc->sc_regs+4);
 249        err |= __get_user(regs->r5, sc->sc_regs+5);
 250        err |= __get_user(regs->r6, sc->sc_regs+6);
 251        err |= __get_user(regs->r7, sc->sc_regs+7);
 252        err |= __get_user(regs->r8, sc->sc_regs+8);
 253        err |= __get_user(sw->r9, sc->sc_regs+9);
 254        err |= __get_user(sw->r10, sc->sc_regs+10);
 255        err |= __get_user(sw->r11, sc->sc_regs+11);
 256        err |= __get_user(sw->r12, sc->sc_regs+12);
 257        err |= __get_user(sw->r13, sc->sc_regs+13);
 258        err |= __get_user(sw->r14, sc->sc_regs+14);
 259        err |= __get_user(sw->r15, sc->sc_regs+15);
 260        err |= __get_user(regs->r16, sc->sc_regs+16);
 261        err |= __get_user(regs->r17, sc->sc_regs+17);
 262        err |= __get_user(regs->r18, sc->sc_regs+18);
 263        err |= __get_user(regs->r19, sc->sc_regs+19);
 264        err |= __get_user(regs->r20, sc->sc_regs+20);
 265        err |= __get_user(regs->r21, sc->sc_regs+21);
 266        err |= __get_user(regs->r22, sc->sc_regs+22);
 267        err |= __get_user(regs->r23, sc->sc_regs+23);
 268        err |= __get_user(regs->r24, sc->sc_regs+24);
 269        err |= __get_user(regs->r25, sc->sc_regs+25);
 270        err |= __get_user(regs->r26, sc->sc_regs+26);
 271        err |= __get_user(regs->r27, sc->sc_regs+27);
 272        err |= __get_user(regs->r28, sc->sc_regs+28);
 273        err |= __get_user(regs->gp, sc->sc_regs+29);
 274        err |= __get_user(usp, sc->sc_regs+30);
 275        wrusp(usp);
 276
 277        for (i = 0; i < 31; i++)
 278                err |= __get_user(sw->fp[i], sc->sc_fpregs+i);
 279        err |= __get_user(sw->fp[31], &sc->sc_fpcr);
 280
 281        return err;
 282}
 283
 284/* Note that this syscall is also used by setcontext(3) to install
 285   a given sigcontext.  This because it's impossible to set *all*
 286   registers and transfer control from userland.  */
 287
 288asmlinkage void
 289do_sigreturn(struct sigcontext __user *sc, struct pt_regs *regs,
 290             struct switch_stack *sw)
 291{
 292        sigset_t set;
 293
 294        /* Verify that it's a good sigcontext before using it */
 295        if (!access_ok(VERIFY_READ, sc, sizeof(*sc)))
 296                goto give_sigsegv;
 297        if (__get_user(set.sig[0], &sc->sc_mask))
 298                goto give_sigsegv;
 299
 300        sigdelsetmask(&set, ~_BLOCKABLE);
 301        spin_lock_irq(&current->sighand->siglock);
 302        current->blocked = set;
 303        recalc_sigpending();
 304        spin_unlock_irq(&current->sighand->siglock);
 305
 306        if (restore_sigcontext(sc, regs, sw))
 307                goto give_sigsegv;
 308
 309        /* Send SIGTRAP if we're single-stepping: */
 310        if (ptrace_cancel_bpt (current)) {
 311                siginfo_t info;
 312
 313                info.si_signo = SIGTRAP;
 314                info.si_errno = 0;
 315                info.si_code = TRAP_BRKPT;
 316                info.si_addr = (void __user *) regs->pc;
 317                info.si_trapno = 0;
 318                send_sig_info(SIGTRAP, &info, current);
 319        }
 320        return;
 321
 322give_sigsegv:
 323        force_sig(SIGSEGV, current);
 324}
 325
 326asmlinkage void
 327do_rt_sigreturn(struct rt_sigframe __user *frame, struct pt_regs *regs,
 328                struct switch_stack *sw)
 329{
 330        sigset_t set;
 331
 332        /* Verify that it's a good ucontext_t before using it */
 333        if (!access_ok(VERIFY_READ, &frame->uc, sizeof(frame->uc)))
 334                goto give_sigsegv;
 335        if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 336                goto give_sigsegv;
 337
 338        sigdelsetmask(&set, ~_BLOCKABLE);
 339        spin_lock_irq(&current->sighand->siglock);
 340        current->blocked = set;
 341        recalc_sigpending();
 342        spin_unlock_irq(&current->sighand->siglock);
 343
 344        if (restore_sigcontext(&frame->uc.uc_mcontext, regs, sw))
 345                goto give_sigsegv;
 346
 347        /* Send SIGTRAP if we're single-stepping: */
 348        if (ptrace_cancel_bpt (current)) {
 349                siginfo_t info;
 350
 351                info.si_signo = SIGTRAP;
 352                info.si_errno = 0;
 353                info.si_code = TRAP_BRKPT;
 354                info.si_addr = (void __user *) regs->pc;
 355                info.si_trapno = 0;
 356                send_sig_info(SIGTRAP, &info, current);
 357        }
 358        return;
 359
 360give_sigsegv:
 361        force_sig(SIGSEGV, current);
 362}
 363
 364
 365/*
 366 * Set up a signal frame.
 367 */
 368
 369static inline void __user *
 370get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
 371{
 372        if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
 373                sp = current->sas_ss_sp + current->sas_ss_size;
 374
 375        return (void __user *)((sp - frame_size) & -32ul);
 376}
 377
 378static long
 379setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, 
 380                 struct switch_stack *sw, unsigned long mask, unsigned long sp)
 381{
 382        long i, err = 0;
 383
 384        err |= __put_user(on_sig_stack((unsigned long)sc), &sc->sc_onstack);
 385        err |= __put_user(mask, &sc->sc_mask);
 386        err |= __put_user(regs->pc, &sc->sc_pc);
 387        err |= __put_user(8, &sc->sc_ps);
 388
 389        err |= __put_user(regs->r0 , sc->sc_regs+0);
 390        err |= __put_user(regs->r1 , sc->sc_regs+1);
 391        err |= __put_user(regs->r2 , sc->sc_regs+2);
 392        err |= __put_user(regs->r3 , sc->sc_regs+3);
 393        err |= __put_user(regs->r4 , sc->sc_regs+4);
 394        err |= __put_user(regs->r5 , sc->sc_regs+5);
 395        err |= __put_user(regs->r6 , sc->sc_regs+6);
 396        err |= __put_user(regs->r7 , sc->sc_regs+7);
 397        err |= __put_user(regs->r8 , sc->sc_regs+8);
 398        err |= __put_user(sw->r9   , sc->sc_regs+9);
 399        err |= __put_user(sw->r10  , sc->sc_regs+10);
 400        err |= __put_user(sw->r11  , sc->sc_regs+11);
 401        err |= __put_user(sw->r12  , sc->sc_regs+12);
 402        err |= __put_user(sw->r13  , sc->sc_regs+13);
 403        err |= __put_user(sw->r14  , sc->sc_regs+14);
 404        err |= __put_user(sw->r15  , sc->sc_regs+15);
 405        err |= __put_user(regs->r16, sc->sc_regs+16);
 406        err |= __put_user(regs->r17, sc->sc_regs+17);
 407        err |= __put_user(regs->r18, sc->sc_regs+18);
 408        err |= __put_user(regs->r19, sc->sc_regs+19);
 409        err |= __put_user(regs->r20, sc->sc_regs+20);
 410        err |= __put_user(regs->r21, sc->sc_regs+21);
 411        err |= __put_user(regs->r22, sc->sc_regs+22);
 412        err |= __put_user(regs->r23, sc->sc_regs+23);
 413        err |= __put_user(regs->r24, sc->sc_regs+24);
 414        err |= __put_user(regs->r25, sc->sc_regs+25);
 415        err |= __put_user(regs->r26, sc->sc_regs+26);
 416        err |= __put_user(regs->r27, sc->sc_regs+27);
 417        err |= __put_user(regs->r28, sc->sc_regs+28);
 418        err |= __put_user(regs->gp , sc->sc_regs+29);
 419        err |= __put_user(sp, sc->sc_regs+30);
 420        err |= __put_user(0, sc->sc_regs+31);
 421
 422        for (i = 0; i < 31; i++)
 423                err |= __put_user(sw->fp[i], sc->sc_fpregs+i);
 424        err |= __put_user(0, sc->sc_fpregs+31);
 425        err |= __put_user(sw->fp[31], &sc->sc_fpcr);
 426
 427        err |= __put_user(regs->trap_a0, &sc->sc_traparg_a0);
 428        err |= __put_user(regs->trap_a1, &sc->sc_traparg_a1);
 429        err |= __put_user(regs->trap_a2, &sc->sc_traparg_a2);
 430
 431        return err;
 432}
 433
 434static int
 435setup_frame(int sig, struct k_sigaction *ka, sigset_t *set,
 436            struct pt_regs *regs, struct switch_stack * sw)
 437{
 438        unsigned long oldsp, r26, err = 0;
 439        struct sigframe __user *frame;
 440
 441        oldsp = rdusp();
 442        frame = get_sigframe(ka, oldsp, sizeof(*frame));
 443        if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 444                goto give_sigsegv;
 445
 446        err |= setup_sigcontext(&frame->sc, regs, sw, set->sig[0], oldsp);
 447        if (err)
 448                goto give_sigsegv;
 449
 450        /* Set up to return from userspace.  If provided, use a stub
 451           already in userspace.  */
 452        if (ka->ka_restorer) {
 453                r26 = (unsigned long) ka->ka_restorer;
 454        } else {
 455                err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
 456                err |= __put_user(INSN_LDI_R0+__NR_sigreturn, frame->retcode+1);
 457                err |= __put_user(INSN_CALLSYS, frame->retcode+2);
 458                imb();
 459                r26 = (unsigned long) frame->retcode;
 460        }
 461
 462        /* Check that everything was written properly.  */
 463        if (err)
 464                goto give_sigsegv;
 465
 466        /* "Return" to the handler */
 467        regs->r26 = r26;
 468        regs->r27 = regs->pc = (unsigned long) ka->sa.sa_handler;
 469        regs->r16 = sig;                        /* a0: signal number */
 470        regs->r17 = 0;                          /* a1: exception code */
 471        regs->r18 = (unsigned long) &frame->sc; /* a2: sigcontext pointer */
 472        wrusp((unsigned long) frame);
 473        
 474#if DEBUG_SIG
 475        printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
 476                current->comm, current->pid, frame, regs->pc, regs->r26);
 477#endif
 478
 479        return 0;
 480
 481give_sigsegv:
 482        force_sigsegv(sig, current);
 483        return -EFAULT;
 484}
 485
 486static int
 487setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 488               sigset_t *set, struct pt_regs *regs, struct switch_stack * sw)
 489{
 490        unsigned long oldsp, r26, err = 0;
 491        struct rt_sigframe __user *frame;
 492
 493        oldsp = rdusp();
 494        frame = get_sigframe(ka, oldsp, sizeof(*frame));
 495        if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 496                goto give_sigsegv;
 497
 498        err |= copy_siginfo_to_user(&frame->info, info);
 499
 500        /* Create the ucontext.  */
 501        err |= __put_user(0, &frame->uc.uc_flags);
 502        err |= __put_user(0, &frame->uc.uc_link);
 503        err |= __put_user(set->sig[0], &frame->uc.uc_osf_sigmask);
 504        err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 505        err |= __put_user(sas_ss_flags(oldsp), &frame->uc.uc_stack.ss_flags);
 506        err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 507        err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, sw,
 508                                set->sig[0], oldsp);
 509        err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 510        if (err)
 511                goto give_sigsegv;
 512
 513        /* Set up to return from userspace.  If provided, use a stub
 514           already in userspace.  */
 515        if (ka->ka_restorer) {
 516                r26 = (unsigned long) ka->ka_restorer;
 517        } else {
 518                err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
 519                err |= __put_user(INSN_LDI_R0+__NR_rt_sigreturn,
 520                                  frame->retcode+1);
 521                err |= __put_user(INSN_CALLSYS, frame->retcode+2);
 522                imb();
 523                r26 = (unsigned long) frame->retcode;
 524        }
 525
 526        if (err)
 527                goto give_sigsegv;
 528
 529        /* "Return" to the handler */
 530        regs->r26 = r26;
 531        regs->r27 = regs->pc = (unsigned long) ka->sa.sa_handler;
 532        regs->r16 = sig;                          /* a0: signal number */
 533        regs->r17 = (unsigned long) &frame->info; /* a1: siginfo pointer */
 534        regs->r18 = (unsigned long) &frame->uc;   /* a2: ucontext pointer */
 535        wrusp((unsigned long) frame);
 536
 537#if DEBUG_SIG
 538        printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
 539                current->comm, current->pid, frame, regs->pc, regs->r26);
 540#endif
 541
 542        return 0;
 543
 544give_sigsegv:
 545        force_sigsegv(sig, current);
 546        return -EFAULT;
 547}
 548
 549
 550/*
 551 * OK, we're invoking a handler.
 552 */
 553static inline int
 554handle_signal(int sig, struct k_sigaction *ka, siginfo_t *info,
 555              sigset_t *oldset, struct pt_regs * regs, struct switch_stack *sw)
 556{
 557        int ret;
 558
 559        if (ka->sa.sa_flags & SA_SIGINFO)
 560                ret = setup_rt_frame(sig, ka, info, oldset, regs, sw);
 561        else
 562                ret = setup_frame(sig, ka, oldset, regs, sw);
 563
 564        if (ret == 0) {
 565                spin_lock_irq(&current->sighand->siglock);
 566                sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 567                if (!(ka->sa.sa_flags & SA_NODEFER)) 
 568                        sigaddset(&current->blocked,sig);
 569                recalc_sigpending();
 570                spin_unlock_irq(&current->sighand->siglock);
 571        }
 572
 573        return ret;
 574}
 575
 576static inline void
 577syscall_restart(unsigned long r0, unsigned long r19,
 578                struct pt_regs *regs, struct k_sigaction *ka)
 579{
 580        switch (regs->r0) {
 581        case ERESTARTSYS:
 582                if (!(ka->sa.sa_flags & SA_RESTART)) {
 583                case ERESTARTNOHAND:
 584                        regs->r0 = EINTR;
 585                        break;
 586                }
 587                /* fallthrough */
 588        case ERESTARTNOINTR:
 589                regs->r0 = r0;  /* reset v0 and a3 and replay syscall */
 590                regs->r19 = r19;
 591                regs->pc -= 4;
 592                break;
 593        case ERESTART_RESTARTBLOCK:
 594                current_thread_info()->restart_block.fn = do_no_restart_syscall;
 595                regs->r0 = EINTR;
 596                break;
 597        }
 598}
 599
 600
 601/*
 602 * Note that 'init' is a special process: it doesn't get signals it doesn't
 603 * want to handle. Thus you cannot kill init even with a SIGKILL even by
 604 * mistake.
 605 *
 606 * Note that we go through the signals twice: once to check the signals that
 607 * the kernel can handle, and then we build all the user-level signal handling
 608 * stack-frames in one go after that.
 609 *
 610 * "r0" and "r19" are the registers we need to restore for system call
 611 * restart. "r0" is also used as an indicator whether we can restart at
 612 * all (if we get here from anything but a syscall return, it will be 0)
 613 */
 614static void
 615do_signal(struct pt_regs * regs, struct switch_stack * sw,
 616          unsigned long r0, unsigned long r19)
 617{
 618        siginfo_t info;
 619        int signr;
 620        unsigned long single_stepping = ptrace_cancel_bpt(current);
 621        struct k_sigaction ka;
 622        sigset_t *oldset;
 623
 624        if (test_thread_flag(TIF_RESTORE_SIGMASK))
 625                oldset = &current->saved_sigmask;
 626        else
 627                oldset = &current->blocked;
 628
 629        /* This lets the debugger run, ... */
 630        signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 631
 632        /* ... so re-check the single stepping. */
 633        single_stepping |= ptrace_cancel_bpt(current);
 634
 635        if (signr > 0) {
 636                /* Whee!  Actually deliver the signal.  */
 637                if (r0)
 638                        syscall_restart(r0, r19, regs, &ka);
 639                if (handle_signal(signr, &ka, &info, oldset, regs, sw) == 0) {
 640                        /* A signal was successfully delivered, and the
 641                           saved sigmask was stored on the signal frame,
 642                           and will be restored by sigreturn.  So we can
 643                           simply clear the restore sigmask flag.  */
 644                        if (test_thread_flag(TIF_RESTORE_SIGMASK))
 645                                clear_thread_flag(TIF_RESTORE_SIGMASK);
 646                }
 647                if (single_stepping) 
 648                        ptrace_set_bpt(current); /* re-set bpt */
 649                return;
 650        }
 651
 652        if (r0) {
 653                switch (regs->r0) {
 654                case ERESTARTNOHAND:
 655                case ERESTARTSYS:
 656                case ERESTARTNOINTR:
 657                        /* Reset v0 and a3 and replay syscall.  */
 658                        regs->r0 = r0;
 659                        regs->r19 = r19;
 660                        regs->pc -= 4;
 661                        break;
 662                case ERESTART_RESTARTBLOCK:
 663                        /* Force v0 to the restart syscall and reply.  */
 664                        regs->r0 = __NR_restart_syscall;
 665                        regs->pc -= 4;
 666                        break;
 667                }
 668        }
 669
 670        /* If there's no signal to deliver, we just restore the saved mask.  */
 671        if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
 672                clear_thread_flag(TIF_RESTORE_SIGMASK);
 673                sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
 674        }
 675
 676        if (single_stepping)
 677                ptrace_set_bpt(current);        /* re-set breakpoint */
 678}
 679
 680void
 681do_notify_resume(struct pt_regs *regs, struct switch_stack *sw,
 682                 unsigned long thread_info_flags,
 683                 unsigned long r0, unsigned long r19)
 684{
 685        if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
 686                do_signal(regs, sw, r0, r19);
 687
 688        if (thread_info_flags & _TIF_NOTIFY_RESUME) {
 689                clear_thread_flag(TIF_NOTIFY_RESUME);
 690                tracehook_notify_resume(regs);
 691                if (current->replacement_session_keyring)
 692                        key_replace_session_keyring();
 693        }
 694}
 695