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