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