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