Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...
[linux-2.6.git] / 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 }