2 * arch/sparc64/kernel/signal.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 * Copyright (C) 1995, 2008 David S. Miller (davem@davemloft.net)
6 * Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
7 * Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be)
8 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
12 #include <linux/compat.h> /* for compat_old_sigset_t */
14 #include <linux/sched.h>
15 #include <linux/kernel.h>
16 #include <linux/signal.h>
17 #include <linux/errno.h>
18 #include <linux/wait.h>
19 #include <linux/ptrace.h>
20 #include <linux/tracehook.h>
21 #include <linux/unistd.h>
23 #include <linux/tty.h>
24 #include <linux/binfmts.h>
25 #include <linux/bitops.h>
27 #include <asm/uaccess.h>
28 #include <asm/ptrace.h>
29 #include <asm/pgtable.h>
30 #include <asm/fpumacro.h>
32 #include <asm/siginfo.h>
33 #include <asm/visasm.h>
38 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
40 /* {set, get}context() needed for 64-bit SparcLinux userland. */
41 asmlinkage
void sparc64_set_context(struct pt_regs
*regs
)
43 struct ucontext __user
*ucp
= (struct ucontext __user
*)
44 regs
->u_regs
[UREG_I0
];
45 mc_gregset_t __user
*grp
;
46 unsigned long pc
, npc
, tstate
;
52 if (get_thread_wsaved() ||
53 (((unsigned long)ucp
) & (sizeof(unsigned long)-1)) ||
54 (!__access_ok(ucp
, sizeof(*ucp
))))
56 grp
= &ucp
->uc_mcontext
.mc_gregs
;
57 err
= __get_user(pc
, &((*grp
)[MC_PC
]));
58 err
|= __get_user(npc
, &((*grp
)[MC_NPC
]));
59 if (err
|| ((pc
| npc
) & 3))
61 if (regs
->u_regs
[UREG_I1
]) {
64 if (_NSIG_WORDS
== 1) {
65 if (__get_user(set
.sig
[0], &ucp
->uc_sigmask
.sig
[0]))
68 if (__copy_from_user(&set
, &ucp
->uc_sigmask
, sizeof(sigset_t
)))
71 sigdelsetmask(&set
, ~_BLOCKABLE
);
72 spin_lock_irq(¤t
->sighand
->siglock
);
73 current
->blocked
= set
;
75 spin_unlock_irq(¤t
->sighand
->siglock
);
77 if (test_thread_flag(TIF_32BIT
)) {
83 err
|= __get_user(regs
->y
, &((*grp
)[MC_Y
]));
84 err
|= __get_user(tstate
, &((*grp
)[MC_TSTATE
]));
85 regs
->tstate
&= ~(TSTATE_ASI
| TSTATE_ICC
| TSTATE_XCC
);
86 regs
->tstate
|= (tstate
& (TSTATE_ASI
| TSTATE_ICC
| TSTATE_XCC
));
87 err
|= __get_user(regs
->u_regs
[UREG_G1
], (&(*grp
)[MC_G1
]));
88 err
|= __get_user(regs
->u_regs
[UREG_G2
], (&(*grp
)[MC_G2
]));
89 err
|= __get_user(regs
->u_regs
[UREG_G3
], (&(*grp
)[MC_G3
]));
90 err
|= __get_user(regs
->u_regs
[UREG_G4
], (&(*grp
)[MC_G4
]));
91 err
|= __get_user(regs
->u_regs
[UREG_G5
], (&(*grp
)[MC_G5
]));
92 err
|= __get_user(regs
->u_regs
[UREG_G6
], (&(*grp
)[MC_G6
]));
94 /* Skip %g7 as that's the thread register in userspace. */
96 err
|= __get_user(regs
->u_regs
[UREG_I0
], (&(*grp
)[MC_O0
]));
97 err
|= __get_user(regs
->u_regs
[UREG_I1
], (&(*grp
)[MC_O1
]));
98 err
|= __get_user(regs
->u_regs
[UREG_I2
], (&(*grp
)[MC_O2
]));
99 err
|= __get_user(regs
->u_regs
[UREG_I3
], (&(*grp
)[MC_O3
]));
100 err
|= __get_user(regs
->u_regs
[UREG_I4
], (&(*grp
)[MC_O4
]));
101 err
|= __get_user(regs
->u_regs
[UREG_I5
], (&(*grp
)[MC_O5
]));
102 err
|= __get_user(regs
->u_regs
[UREG_I6
], (&(*grp
)[MC_O6
]));
103 err
|= __get_user(regs
->u_regs
[UREG_I7
], (&(*grp
)[MC_O7
]));
105 err
|= __get_user(fp
, &(ucp
->uc_mcontext
.mc_fp
));
106 err
|= __get_user(i7
, &(ucp
->uc_mcontext
.mc_i7
));
107 err
|= __put_user(fp
,
108 (&(((struct reg_window __user
*)(STACK_BIAS
+regs
->u_regs
[UREG_I6
]))->ins
[6])));
109 err
|= __put_user(i7
,
110 (&(((struct reg_window __user
*)(STACK_BIAS
+regs
->u_regs
[UREG_I6
]))->ins
[7])));
112 err
|= __get_user(fenab
, &(ucp
->uc_mcontext
.mc_fpregs
.mcfpu_enab
));
114 unsigned long *fpregs
= current_thread_info()->fpregs
;
118 err
|= __get_user(fprs
, &(ucp
->uc_mcontext
.mc_fpregs
.mcfpu_fprs
));
120 err
|= copy_from_user(fpregs
,
121 &(ucp
->uc_mcontext
.mc_fpregs
.mcfpu_fregs
),
122 (sizeof(unsigned int) * 32));
124 err
|= copy_from_user(fpregs
+16,
125 ((unsigned long __user
*)&(ucp
->uc_mcontext
.mc_fpregs
.mcfpu_fregs
))+16,
126 (sizeof(unsigned int) * 32));
127 err
|= __get_user(current_thread_info()->xfsr
[0],
128 &(ucp
->uc_mcontext
.mc_fpregs
.mcfpu_fsr
));
129 err
|= __get_user(current_thread_info()->gsr
[0],
130 &(ucp
->uc_mcontext
.mc_fpregs
.mcfpu_gsr
));
131 regs
->tstate
&= ~TSTATE_PEF
;
138 force_sig(SIGSEGV
, current
);
141 asmlinkage
void sparc64_get_context(struct pt_regs
*regs
)
143 struct ucontext __user
*ucp
= (struct ucontext __user
*)
144 regs
->u_regs
[UREG_I0
];
145 mc_gregset_t __user
*grp
;
146 mcontext_t __user
*mcp
;
147 unsigned long fp
, i7
;
151 synchronize_user_stack();
152 if (get_thread_wsaved() || clear_user(ucp
, sizeof(*ucp
)))
155 fenab
= 0; /* IMO get_context is like any other system call, thus modifies FPU state -jj */
157 mcp
= &ucp
->uc_mcontext
;
158 grp
= &mcp
->mc_gregs
;
160 /* Skip over the trap instruction, first. */
161 if (test_thread_flag(TIF_32BIT
)) {
162 regs
->tpc
= (regs
->tnpc
& 0xffffffff);
163 regs
->tnpc
= (regs
->tnpc
+ 4) & 0xffffffff;
165 regs
->tpc
= regs
->tnpc
;
169 if (_NSIG_WORDS
== 1)
170 err
|= __put_user(current
->blocked
.sig
[0],
171 (unsigned long __user
*)&ucp
->uc_sigmask
);
173 err
|= __copy_to_user(&ucp
->uc_sigmask
, ¤t
->blocked
,
176 err
|= __put_user(regs
->tstate
, &((*grp
)[MC_TSTATE
]));
177 err
|= __put_user(regs
->tpc
, &((*grp
)[MC_PC
]));
178 err
|= __put_user(regs
->tnpc
, &((*grp
)[MC_NPC
]));
179 err
|= __put_user(regs
->y
, &((*grp
)[MC_Y
]));
180 err
|= __put_user(regs
->u_regs
[UREG_G1
], &((*grp
)[MC_G1
]));
181 err
|= __put_user(regs
->u_regs
[UREG_G2
], &((*grp
)[MC_G2
]));
182 err
|= __put_user(regs
->u_regs
[UREG_G3
], &((*grp
)[MC_G3
]));
183 err
|= __put_user(regs
->u_regs
[UREG_G4
], &((*grp
)[MC_G4
]));
184 err
|= __put_user(regs
->u_regs
[UREG_G5
], &((*grp
)[MC_G5
]));
185 err
|= __put_user(regs
->u_regs
[UREG_G6
], &((*grp
)[MC_G6
]));
186 err
|= __put_user(regs
->u_regs
[UREG_G7
], &((*grp
)[MC_G7
]));
187 err
|= __put_user(regs
->u_regs
[UREG_I0
], &((*grp
)[MC_O0
]));
188 err
|= __put_user(regs
->u_regs
[UREG_I1
], &((*grp
)[MC_O1
]));
189 err
|= __put_user(regs
->u_regs
[UREG_I2
], &((*grp
)[MC_O2
]));
190 err
|= __put_user(regs
->u_regs
[UREG_I3
], &((*grp
)[MC_O3
]));
191 err
|= __put_user(regs
->u_regs
[UREG_I4
], &((*grp
)[MC_O4
]));
192 err
|= __put_user(regs
->u_regs
[UREG_I5
], &((*grp
)[MC_O5
]));
193 err
|= __put_user(regs
->u_regs
[UREG_I6
], &((*grp
)[MC_O6
]));
194 err
|= __put_user(regs
->u_regs
[UREG_I7
], &((*grp
)[MC_O7
]));
196 err
|= __get_user(fp
,
197 (&(((struct reg_window __user
*)(STACK_BIAS
+regs
->u_regs
[UREG_I6
]))->ins
[6])));
198 err
|= __get_user(i7
,
199 (&(((struct reg_window __user
*)(STACK_BIAS
+regs
->u_regs
[UREG_I6
]))->ins
[7])));
200 err
|= __put_user(fp
, &(mcp
->mc_fp
));
201 err
|= __put_user(i7
, &(mcp
->mc_i7
));
203 err
|= __put_user(fenab
, &(mcp
->mc_fpregs
.mcfpu_enab
));
205 unsigned long *fpregs
= current_thread_info()->fpregs
;
208 fprs
= current_thread_info()->fpsaved
[0];
210 err
|= copy_to_user(&(mcp
->mc_fpregs
.mcfpu_fregs
), fpregs
,
211 (sizeof(unsigned int) * 32));
214 ((unsigned long __user
*)&(mcp
->mc_fpregs
.mcfpu_fregs
))+16, fpregs
+16,
215 (sizeof(unsigned int) * 32));
216 err
|= __put_user(current_thread_info()->xfsr
[0], &(mcp
->mc_fpregs
.mcfpu_fsr
));
217 err
|= __put_user(current_thread_info()->gsr
[0], &(mcp
->mc_fpregs
.mcfpu_gsr
));
218 err
|= __put_user(fprs
, &(mcp
->mc_fpregs
.mcfpu_fprs
));
225 force_sig(SIGSEGV
, current
);
228 struct rt_signal_frame
{
229 struct sparc_stackf ss
;
232 __siginfo_fpu_t __user
*fpu_save
;
235 __siginfo_fpu_t fpu_state
;
238 static long _sigpause_common(old_sigset_t set
)
241 spin_lock_irq(¤t
->sighand
->siglock
);
242 current
->saved_sigmask
= current
->blocked
;
243 siginitset(¤t
->blocked
, set
);
245 spin_unlock_irq(¤t
->sighand
->siglock
);
247 current
->state
= TASK_INTERRUPTIBLE
;
250 set_restore_sigmask();
252 return -ERESTARTNOHAND
;
255 asmlinkage
long sys_sigpause(unsigned int set
)
257 return _sigpause_common(set
);
260 asmlinkage
long sys_sigsuspend(old_sigset_t set
)
262 return _sigpause_common(set
);
266 restore_fpu_state(struct pt_regs
*regs
, __siginfo_fpu_t __user
*fpu
)
268 unsigned long *fpregs
= current_thread_info()->fpregs
;
272 err
= __get_user(fprs
, &fpu
->si_fprs
);
274 regs
->tstate
&= ~TSTATE_PEF
;
276 err
|= copy_from_user(fpregs
, &fpu
->si_float_regs
[0],
277 (sizeof(unsigned int) * 32));
279 err
|= copy_from_user(fpregs
+16, &fpu
->si_float_regs
[32],
280 (sizeof(unsigned int) * 32));
281 err
|= __get_user(current_thread_info()->xfsr
[0], &fpu
->si_fsr
);
282 err
|= __get_user(current_thread_info()->gsr
[0], &fpu
->si_gsr
);
283 current_thread_info()->fpsaved
[0] |= fprs
;
287 void do_rt_sigreturn(struct pt_regs
*regs
)
289 struct rt_signal_frame __user
*sf
;
290 unsigned long tpc
, tnpc
, tstate
;
291 __siginfo_fpu_t __user
*fpu_save
;
295 /* Always make any pending restarted system calls return -EINTR */
296 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
298 synchronize_user_stack ();
299 sf
= (struct rt_signal_frame __user
*)
300 (regs
->u_regs
[UREG_FP
] + STACK_BIAS
);
302 /* 1. Make sure we are not getting garbage from the user */
303 if (((unsigned long) sf
) & 3)
306 err
= get_user(tpc
, &sf
->regs
.tpc
);
307 err
|= __get_user(tnpc
, &sf
->regs
.tnpc
);
308 if (test_thread_flag(TIF_32BIT
)) {
312 err
|= ((tpc
| tnpc
) & 3);
314 /* 2. Restore the state */
315 err
|= __get_user(regs
->y
, &sf
->regs
.y
);
316 err
|= __get_user(tstate
, &sf
->regs
.tstate
);
317 err
|= copy_from_user(regs
->u_regs
, sf
->regs
.u_regs
, sizeof(regs
->u_regs
));
319 /* User can only change condition codes and %asi in %tstate. */
320 regs
->tstate
&= ~(TSTATE_ASI
| TSTATE_ICC
| TSTATE_XCC
);
321 regs
->tstate
|= (tstate
& (TSTATE_ASI
| TSTATE_ICC
| TSTATE_XCC
));
323 err
|= __get_user(fpu_save
, &sf
->fpu_save
);
325 err
|= restore_fpu_state(regs
, &sf
->fpu_state
);
327 err
|= __copy_from_user(&set
, &sf
->mask
, sizeof(sigset_t
));
328 err
|= do_sigaltstack(&sf
->stack
, NULL
, (unsigned long)sf
);
336 /* Prevent syscall restart. */
337 pt_regs_clear_syscall(regs
);
339 sigdelsetmask(&set
, ~_BLOCKABLE
);
340 spin_lock_irq(¤t
->sighand
->siglock
);
341 current
->blocked
= set
;
343 spin_unlock_irq(¤t
->sighand
->siglock
);
346 force_sig(SIGSEGV
, current
);
349 /* Checks if the fp is valid */
350 static int invalid_frame_pointer(void __user
*fp
, int fplen
)
352 if (((unsigned long) fp
) & 15)
358 save_fpu_state(struct pt_regs
*regs
, __siginfo_fpu_t __user
*fpu
)
360 unsigned long *fpregs
= current_thread_info()->fpregs
;
364 fprs
= current_thread_info()->fpsaved
[0];
366 err
|= copy_to_user(&fpu
->si_float_regs
[0], fpregs
,
367 (sizeof(unsigned int) * 32));
369 err
|= copy_to_user(&fpu
->si_float_regs
[32], fpregs
+16,
370 (sizeof(unsigned int) * 32));
371 err
|= __put_user(current_thread_info()->xfsr
[0], &fpu
->si_fsr
);
372 err
|= __put_user(current_thread_info()->gsr
[0], &fpu
->si_gsr
);
373 err
|= __put_user(fprs
, &fpu
->si_fprs
);
378 static inline void __user
*get_sigframe(struct k_sigaction
*ka
, struct pt_regs
*regs
, unsigned long framesize
)
380 unsigned long sp
= regs
->u_regs
[UREG_FP
] + STACK_BIAS
;
383 * If we are on the alternate signal stack and would overflow it, don't.
384 * Return an always-bogus address instead so we will die with SIGSEGV.
386 if (on_sig_stack(sp
) && !likely(on_sig_stack(sp
- framesize
)))
387 return (void __user
*) -1L;
389 /* This is the X/Open sanctioned signal stack switching. */
390 if (ka
->sa
.sa_flags
& SA_ONSTACK
) {
391 if (sas_ss_flags(sp
) == 0)
392 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
397 /* Always align the stack frame. This handles two cases. First,
398 * sigaltstack need not be mindful of platform specific stack
399 * alignment. Second, if we took this signal because the stack
400 * is not aligned properly, we'd like to take the signal cleanly
405 return (void __user
*) sp
;
409 setup_rt_frame(struct k_sigaction
*ka
, struct pt_regs
*regs
,
410 int signo
, sigset_t
*oldset
, siginfo_t
*info
)
412 struct rt_signal_frame __user
*sf
;
413 int sigframe_size
, err
;
415 /* 1. Make sure everything is clean */
416 synchronize_user_stack();
417 save_and_clear_fpu();
419 sigframe_size
= sizeof(struct rt_signal_frame
);
420 if (!(current_thread_info()->fpsaved
[0] & FPRS_FEF
))
421 sigframe_size
-= sizeof(__siginfo_fpu_t
);
423 sf
= (struct rt_signal_frame __user
*)
424 get_sigframe(ka
, regs
, sigframe_size
);
426 if (invalid_frame_pointer (sf
, sigframe_size
))
429 if (get_thread_wsaved() != 0)
432 /* 2. Save the current process state */
433 err
= copy_to_user(&sf
->regs
, regs
, sizeof (*regs
));
435 if (current_thread_info()->fpsaved
[0] & FPRS_FEF
) {
436 err
|= save_fpu_state(regs
, &sf
->fpu_state
);
437 err
|= __put_user((u64
)&sf
->fpu_state
, &sf
->fpu_save
);
439 err
|= __put_user(0, &sf
->fpu_save
);
442 /* Setup sigaltstack */
443 err
|= __put_user(current
->sas_ss_sp
, &sf
->stack
.ss_sp
);
444 err
|= __put_user(sas_ss_flags(regs
->u_regs
[UREG_FP
]), &sf
->stack
.ss_flags
);
445 err
|= __put_user(current
->sas_ss_size
, &sf
->stack
.ss_size
);
447 err
|= copy_to_user(&sf
->mask
, oldset
, sizeof(sigset_t
));
449 err
|= copy_in_user((u64 __user
*)sf
,
450 (u64 __user
*)(regs
->u_regs
[UREG_FP
]+STACK_BIAS
),
451 sizeof(struct reg_window
));
454 err
|= copy_siginfo_to_user(&sf
->info
, info
);
456 err
|= __put_user(signo
, &sf
->info
.si_signo
);
457 err
|= __put_user(SI_NOINFO
, &sf
->info
.si_code
);
462 /* 3. signal handler back-trampoline and parameters */
463 regs
->u_regs
[UREG_FP
] = ((unsigned long) sf
) - STACK_BIAS
;
464 regs
->u_regs
[UREG_I0
] = signo
;
465 regs
->u_regs
[UREG_I1
] = (unsigned long) &sf
->info
;
467 /* The sigcontext is passed in this way because of how it
468 * is defined in GLIBC's /usr/include/bits/sigcontext.h
469 * for sparc64. It includes the 128 bytes of siginfo_t.
471 regs
->u_regs
[UREG_I2
] = (unsigned long) &sf
->info
;
473 /* 5. signal handler */
474 regs
->tpc
= (unsigned long) ka
->sa
.sa_handler
;
475 regs
->tnpc
= (regs
->tpc
+ 4);
476 if (test_thread_flag(TIF_32BIT
)) {
477 regs
->tpc
&= 0xffffffff;
478 regs
->tnpc
&= 0xffffffff;
480 /* 4. return to kernel instructions */
481 regs
->u_regs
[UREG_I7
] = (unsigned long)ka
->ka_restorer
;
489 force_sigsegv(signo
, current
);
493 static inline int handle_signal(unsigned long signr
, struct k_sigaction
*ka
,
495 sigset_t
*oldset
, struct pt_regs
*regs
)
499 err
= setup_rt_frame(ka
, regs
, signr
, oldset
,
500 (ka
->sa
.sa_flags
& SA_SIGINFO
) ? info
: NULL
);
503 spin_lock_irq(¤t
->sighand
->siglock
);
504 sigorsets(¤t
->blocked
,¤t
->blocked
,&ka
->sa
.sa_mask
);
505 if (!(ka
->sa
.sa_flags
& SA_NOMASK
))
506 sigaddset(¤t
->blocked
,signr
);
508 spin_unlock_irq(¤t
->sighand
->siglock
);
510 tracehook_signal_handler(signr
, info
, ka
, regs
, 0);
515 static inline void syscall_restart(unsigned long orig_i0
, struct pt_regs
*regs
,
516 struct sigaction
*sa
)
518 switch (regs
->u_regs
[UREG_I0
]) {
519 case ERESTART_RESTARTBLOCK
:
521 no_system_call_restart
:
522 regs
->u_regs
[UREG_I0
] = EINTR
;
523 regs
->tstate
|= (TSTATE_ICARRY
|TSTATE_XCARRY
);
526 if (!(sa
->sa_flags
& SA_RESTART
))
527 goto no_system_call_restart
;
530 regs
->u_regs
[UREG_I0
] = orig_i0
;
536 /* Note that 'init' is a special process: it doesn't get signals it doesn't
537 * want to handle. Thus you cannot kill init even with a SIGKILL even by
540 static void do_signal(struct pt_regs
*regs
, unsigned long orig_i0
)
542 struct k_sigaction ka
;
548 if (pt_regs_is_syscall(regs
) &&
549 (regs
->tstate
& (TSTATE_XCARRY
| TSTATE_ICARRY
))) {
554 if (current_thread_info()->status
& TS_RESTORE_SIGMASK
)
555 oldset
= ¤t
->saved_sigmask
;
557 oldset
= ¤t
->blocked
;
560 if (test_thread_flag(TIF_32BIT
)) {
561 extern void do_signal32(sigset_t
*, struct pt_regs
*,
563 unsigned long orig_i0
);
564 do_signal32(oldset
, regs
, restart_syscall
, orig_i0
);
569 signr
= get_signal_to_deliver(&info
, &ka
, regs
, NULL
);
571 /* If the debugger messes with the program counter, it clears
572 * the software "in syscall" bit, directing us to not perform
575 if (restart_syscall
&& !pt_regs_is_syscall(regs
))
580 syscall_restart(orig_i0
, regs
, &ka
.sa
);
581 if (handle_signal(signr
, &ka
, &info
, oldset
, regs
) == 0) {
582 /* A signal was successfully delivered; the saved
583 * sigmask will have been stored in the signal frame,
584 * and will be restored by sigreturn, so we can simply
585 * clear the TS_RESTORE_SIGMASK flag.
587 current_thread_info()->status
&= ~TS_RESTORE_SIGMASK
;
591 if (restart_syscall
&&
592 (regs
->u_regs
[UREG_I0
] == ERESTARTNOHAND
||
593 regs
->u_regs
[UREG_I0
] == ERESTARTSYS
||
594 regs
->u_regs
[UREG_I0
] == ERESTARTNOINTR
)) {
595 /* replay the system call when we are done */
596 regs
->u_regs
[UREG_I0
] = orig_i0
;
599 pt_regs_clear_syscall(regs
);
601 if (restart_syscall
&&
602 regs
->u_regs
[UREG_I0
] == ERESTART_RESTARTBLOCK
) {
603 regs
->u_regs
[UREG_G1
] = __NR_restart_syscall
;
606 pt_regs_clear_syscall(regs
);
609 /* If there's no signal to deliver, we just put the saved sigmask
612 if (current_thread_info()->status
& TS_RESTORE_SIGMASK
) {
613 current_thread_info()->status
&= ~TS_RESTORE_SIGMASK
;
614 sigprocmask(SIG_SETMASK
, ¤t
->saved_sigmask
, NULL
);
618 void do_notify_resume(struct pt_regs
*regs
, unsigned long orig_i0
, unsigned long thread_info_flags
)
620 if (thread_info_flags
& _TIF_SIGPENDING
)
621 do_signal(regs
, orig_i0
);
622 if (thread_info_flags
& _TIF_NOTIFY_RESUME
) {
623 clear_thread_flag(TIF_NOTIFY_RESUME
);
624 tracehook_notify_resume(regs
);
625 if (current
->replacement_session_keyring
)
626 key_replace_session_keyring();