Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * arch/s390/kernel/signal.c | |
3 | * | |
54dfe5dd | 4 | * Copyright (C) IBM Corp. 1999,2006 |
1da177e4 LT |
5 | * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com) |
6 | * | |
7 | * Based on Intel version | |
8 | * | |
9 | * Copyright (C) 1991, 1992 Linus Torvalds | |
10 | * | |
11 | * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson | |
12 | */ | |
13 | ||
1da177e4 LT |
14 | #include <linux/sched.h> |
15 | #include <linux/mm.h> | |
16 | #include <linux/smp.h> | |
1da177e4 LT |
17 | #include <linux/kernel.h> |
18 | #include <linux/signal.h> | |
19 | #include <linux/errno.h> | |
20 | #include <linux/wait.h> | |
21 | #include <linux/ptrace.h> | |
22 | #include <linux/unistd.h> | |
23 | #include <linux/stddef.h> | |
24 | #include <linux/tty.h> | |
25 | #include <linux/personality.h> | |
26 | #include <linux/binfmts.h> | |
753c4dd6 | 27 | #include <linux/tracehook.h> |
26689452 | 28 | #include <linux/syscalls.h> |
7757591a | 29 | #include <linux/compat.h> |
1da177e4 LT |
30 | #include <asm/ucontext.h> |
31 | #include <asm/uaccess.h> | |
32 | #include <asm/lowcore.h> | |
a0616cde | 33 | #include <asm/switch_to.h> |
a806170e | 34 | #include "entry.h" |
1da177e4 | 35 | |
1da177e4 LT |
36 | typedef struct |
37 | { | |
38 | __u8 callee_used_stack[__SIGNAL_FRAMESIZE]; | |
39 | struct sigcontext sc; | |
40 | _sigregs sregs; | |
41 | int signo; | |
42 | __u8 retcode[S390_SYSCALL_SIZE]; | |
43 | } sigframe; | |
44 | ||
45 | typedef struct | |
46 | { | |
47 | __u8 callee_used_stack[__SIGNAL_FRAMESIZE]; | |
48 | __u8 retcode[S390_SYSCALL_SIZE]; | |
49 | struct siginfo info; | |
50 | struct ucontext uc; | |
51 | } rt_sigframe; | |
52 | ||
1da177e4 LT |
53 | /* |
54 | * Atomically swap in the new signal mask, and wait for a signal. | |
55 | */ | |
26689452 | 56 | SYSCALL_DEFINE3(sigsuspend, int, history0, int, history1, old_sigset_t, mask) |
1da177e4 | 57 | { |
391c62fe | 58 | sigset_t blocked; |
391c62fe | 59 | siginitset(&blocked, mask); |
68f3f16d | 60 | return sigsuspend(&blocked); |
1da177e4 LT |
61 | } |
62 | ||
26689452 HC |
63 | SYSCALL_DEFINE3(sigaction, int, sig, const struct old_sigaction __user *, act, |
64 | struct old_sigaction __user *, oact) | |
1da177e4 LT |
65 | { |
66 | struct k_sigaction new_ka, old_ka; | |
67 | int ret; | |
68 | ||
69 | if (act) { | |
70 | old_sigset_t mask; | |
71 | if (!access_ok(VERIFY_READ, act, sizeof(*act)) || | |
72 | __get_user(new_ka.sa.sa_handler, &act->sa_handler) || | |
12bae235 HC |
73 | __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) || |
74 | __get_user(new_ka.sa.sa_flags, &act->sa_flags) || | |
75 | __get_user(mask, &act->sa_mask)) | |
1da177e4 | 76 | return -EFAULT; |
1da177e4 LT |
77 | siginitset(&new_ka.sa.sa_mask, mask); |
78 | } | |
79 | ||
80 | ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); | |
81 | ||
82 | if (!ret && oact) { | |
83 | if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) || | |
84 | __put_user(old_ka.sa.sa_handler, &oact->sa_handler) || | |
12bae235 HC |
85 | __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) || |
86 | __put_user(old_ka.sa.sa_flags, &oact->sa_flags) || | |
87 | __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask)) | |
1da177e4 | 88 | return -EFAULT; |
1da177e4 LT |
89 | } |
90 | ||
91 | return ret; | |
92 | } | |
93 | ||
26689452 HC |
94 | SYSCALL_DEFINE2(sigaltstack, const stack_t __user *, uss, |
95 | stack_t __user *, uoss) | |
1da177e4 | 96 | { |
03ff9a23 | 97 | struct pt_regs *regs = task_pt_regs(current); |
1da177e4 LT |
98 | return do_sigaltstack(uss, uoss, regs->gprs[15]); |
99 | } | |
100 | ||
1da177e4 LT |
101 | /* Returns non-zero on fault. */ |
102 | static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs) | |
103 | { | |
6837a8c3 GS |
104 | _sigregs user_sregs; |
105 | ||
1da177e4 LT |
106 | save_access_regs(current->thread.acrs); |
107 | ||
108 | /* Copy a 'clean' PSW mask to the user to avoid leaking | |
109 | information about whether PER is currently on. */ | |
d4e81b35 MS |
110 | user_sregs.regs.psw.mask = psw_user_bits | |
111 | (regs->psw.mask & PSW_MASK_USER); | |
b05e3703 MS |
112 | user_sregs.regs.psw.addr = regs->psw.addr; |
113 | memcpy(&user_sregs.regs.gprs, ®s->gprs, sizeof(sregs->regs.gprs)); | |
6837a8c3 GS |
114 | memcpy(&user_sregs.regs.acrs, current->thread.acrs, |
115 | sizeof(sregs->regs.acrs)); | |
1da177e4 LT |
116 | /* |
117 | * We have to store the fp registers to current->thread.fp_regs | |
118 | * to merge them with the emulated registers. | |
119 | */ | |
120 | save_fp_regs(¤t->thread.fp_regs); | |
6837a8c3 GS |
121 | memcpy(&user_sregs.fpregs, ¤t->thread.fp_regs, |
122 | sizeof(s390_fp_regs)); | |
123 | return __copy_to_user(sregs, &user_sregs, sizeof(_sigregs)); | |
1da177e4 LT |
124 | } |
125 | ||
126 | /* Returns positive number on error */ | |
127 | static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs) | |
128 | { | |
1da177e4 | 129 | int err; |
6837a8c3 | 130 | _sigregs user_sregs; |
1da177e4 LT |
131 | |
132 | /* Alwys make any pending restarted system call return -EINTR */ | |
133 | current_thread_info()->restart_block.fn = do_no_restart_syscall; | |
134 | ||
6837a8c3 | 135 | err = __copy_from_user(&user_sregs, sregs, sizeof(_sigregs)); |
1da177e4 LT |
136 | if (err) |
137 | return err; | |
d4e81b35 | 138 | /* Use regs->psw.mask instead of psw_user_bits to preserve PER bit. */ |
b50511e4 | 139 | regs->psw.mask = (regs->psw.mask & ~PSW_MASK_USER) | |
d4e81b35 MS |
140 | (user_sregs.regs.psw.mask & PSW_MASK_USER); |
141 | /* Check for invalid amode */ | |
142 | if (regs->psw.mask & PSW_MASK_EA) | |
143 | regs->psw.mask |= PSW_MASK_BA; | |
144 | regs->psw.addr = user_sregs.regs.psw.addr; | |
b05e3703 | 145 | memcpy(®s->gprs, &user_sregs.regs.gprs, sizeof(sregs->regs.gprs)); |
6837a8c3 GS |
146 | memcpy(¤t->thread.acrs, &user_sregs.regs.acrs, |
147 | sizeof(sregs->regs.acrs)); | |
1da177e4 LT |
148 | restore_access_regs(current->thread.acrs); |
149 | ||
6837a8c3 GS |
150 | memcpy(¤t->thread.fp_regs, &user_sregs.fpregs, |
151 | sizeof(s390_fp_regs)); | |
1da177e4 | 152 | current->thread.fp_regs.fpc &= FPC_VALID_MASK; |
1da177e4 LT |
153 | |
154 | restore_fp_regs(¤t->thread.fp_regs); | |
b6ef5bb3 | 155 | clear_thread_flag(TIF_SYSCALL); /* No longer in a system call */ |
1da177e4 LT |
156 | return 0; |
157 | } | |
158 | ||
26689452 | 159 | SYSCALL_DEFINE0(sigreturn) |
1da177e4 | 160 | { |
03ff9a23 | 161 | struct pt_regs *regs = task_pt_regs(current); |
1da177e4 LT |
162 | sigframe __user *frame = (sigframe __user *)regs->gprs[15]; |
163 | sigset_t set; | |
164 | ||
165 | if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) | |
166 | goto badframe; | |
167 | if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE)) | |
168 | goto badframe; | |
391c62fe | 169 | set_current_blocked(&set); |
1da177e4 LT |
170 | if (restore_sigregs(regs, &frame->sregs)) |
171 | goto badframe; | |
1da177e4 | 172 | return regs->gprs[2]; |
1da177e4 LT |
173 | badframe: |
174 | force_sig(SIGSEGV, current); | |
175 | return 0; | |
176 | } | |
177 | ||
26689452 | 178 | SYSCALL_DEFINE0(rt_sigreturn) |
1da177e4 | 179 | { |
03ff9a23 | 180 | struct pt_regs *regs = task_pt_regs(current); |
1da177e4 LT |
181 | rt_sigframe __user *frame = (rt_sigframe __user *)regs->gprs[15]; |
182 | sigset_t set; | |
183 | ||
184 | if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) | |
185 | goto badframe; | |
186 | if (__copy_from_user(&set.sig, &frame->uc.uc_sigmask, sizeof(set))) | |
187 | goto badframe; | |
391c62fe | 188 | set_current_blocked(&set); |
1da177e4 LT |
189 | if (restore_sigregs(regs, &frame->uc.uc_mcontext)) |
190 | goto badframe; | |
4e3df37e CLG |
191 | if (do_sigaltstack(&frame->uc.uc_stack, NULL, |
192 | regs->gprs[15]) == -EFAULT) | |
193 | goto badframe; | |
1da177e4 | 194 | return regs->gprs[2]; |
1da177e4 LT |
195 | badframe: |
196 | force_sig(SIGSEGV, current); | |
197 | return 0; | |
198 | } | |
199 | ||
200 | /* | |
201 | * Set up a signal frame. | |
202 | */ | |
203 | ||
204 | ||
205 | /* | |
206 | * Determine which stack to use.. | |
207 | */ | |
208 | static inline void __user * | |
209 | get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size) | |
210 | { | |
211 | unsigned long sp; | |
212 | ||
213 | /* Default to using normal stack */ | |
214 | sp = regs->gprs[15]; | |
215 | ||
de553438 HC |
216 | /* Overflow on alternate signal stack gives SIGSEGV. */ |
217 | if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL)) | |
218 | return (void __user *) -1UL; | |
219 | ||
1da177e4 LT |
220 | /* This is the X/Open sanctioned signal stack switching. */ |
221 | if (ka->sa.sa_flags & SA_ONSTACK) { | |
222 | if (! sas_ss_flags(sp)) | |
223 | sp = current->sas_ss_sp + current->sas_ss_size; | |
224 | } | |
225 | ||
1da177e4 LT |
226 | return (void __user *)((sp - frame_size) & -8ul); |
227 | } | |
228 | ||
229 | static inline int map_signal(int sig) | |
230 | { | |
231 | if (current_thread_info()->exec_domain | |
232 | && current_thread_info()->exec_domain->signal_invmap | |
233 | && sig < 32) | |
234 | return current_thread_info()->exec_domain->signal_invmap[sig]; | |
235 | else | |
236 | return sig; | |
237 | } | |
238 | ||
54dfe5dd HC |
239 | static int setup_frame(int sig, struct k_sigaction *ka, |
240 | sigset_t *set, struct pt_regs * regs) | |
1da177e4 LT |
241 | { |
242 | sigframe __user *frame; | |
243 | ||
244 | frame = get_sigframe(ka, regs, sizeof(sigframe)); | |
245 | if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe))) | |
246 | goto give_sigsegv; | |
247 | ||
de553438 HC |
248 | if (frame == (void __user *) -1UL) |
249 | goto give_sigsegv; | |
250 | ||
1da177e4 LT |
251 | if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE)) |
252 | goto give_sigsegv; | |
253 | ||
254 | if (save_sigregs(regs, &frame->sregs)) | |
255 | goto give_sigsegv; | |
256 | if (__put_user(&frame->sregs, &frame->sc.sregs)) | |
257 | goto give_sigsegv; | |
258 | ||
259 | /* Set up to return from userspace. If provided, use a stub | |
260 | already in userspace. */ | |
261 | if (ka->sa.sa_flags & SA_RESTORER) { | |
262 | regs->gprs[14] = (unsigned long) | |
263 | ka->sa.sa_restorer | PSW_ADDR_AMODE; | |
264 | } else { | |
265 | regs->gprs[14] = (unsigned long) | |
266 | frame->retcode | PSW_ADDR_AMODE; | |
267 | if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, | |
268 | (u16 __user *)(frame->retcode))) | |
269 | goto give_sigsegv; | |
270 | } | |
271 | ||
272 | /* Set up backchain. */ | |
273 | if (__put_user(regs->gprs[15], (addr_t __user *) frame)) | |
274 | goto give_sigsegv; | |
275 | ||
276 | /* Set up registers for signal handler */ | |
277 | regs->gprs[15] = (unsigned long) frame; | |
d4e81b35 | 278 | regs->psw.mask |= PSW_MASK_EA | PSW_MASK_BA; /* 64 bit amode */ |
1da177e4 LT |
279 | regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE; |
280 | ||
281 | regs->gprs[2] = map_signal(sig); | |
282 | regs->gprs[3] = (unsigned long) &frame->sc; | |
283 | ||
284 | /* We forgot to include these in the sigcontext. | |
285 | To avoid breaking binary compatibility, they are passed as args. */ | |
aa33c8cb MS |
286 | if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL || |
287 | sig == SIGTRAP || sig == SIGFPE) { | |
288 | /* set extra registers only for synchronous signals */ | |
289 | regs->gprs[4] = regs->int_code & 127; | |
290 | regs->gprs[5] = regs->int_parm_long; | |
291 | regs->gprs[6] = task_thread_info(current)->last_break; | |
292 | } | |
1da177e4 LT |
293 | |
294 | /* Place signal number on stack to allow backtrace from handler. */ | |
295 | if (__put_user(regs->gprs[2], (int __user *) &frame->signo)) | |
296 | goto give_sigsegv; | |
54dfe5dd | 297 | return 0; |
1da177e4 LT |
298 | |
299 | give_sigsegv: | |
300 | force_sigsegv(sig, current); | |
54dfe5dd | 301 | return -EFAULT; |
1da177e4 LT |
302 | } |
303 | ||
54dfe5dd | 304 | static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, |
1da177e4 LT |
305 | sigset_t *set, struct pt_regs * regs) |
306 | { | |
307 | int err = 0; | |
308 | rt_sigframe __user *frame; | |
309 | ||
310 | frame = get_sigframe(ka, regs, sizeof(rt_sigframe)); | |
311 | if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe))) | |
312 | goto give_sigsegv; | |
313 | ||
de553438 HC |
314 | if (frame == (void __user *) -1UL) |
315 | goto give_sigsegv; | |
316 | ||
1da177e4 LT |
317 | if (copy_siginfo_to_user(&frame->info, info)) |
318 | goto give_sigsegv; | |
319 | ||
320 | /* Create the ucontext. */ | |
321 | err |= __put_user(0, &frame->uc.uc_flags); | |
c2814476 AV |
322 | err |= __put_user(NULL, &frame->uc.uc_link); |
323 | err |= __put_user((void __user *)current->sas_ss_sp, &frame->uc.uc_stack.ss_sp); | |
1da177e4 LT |
324 | err |= __put_user(sas_ss_flags(regs->gprs[15]), |
325 | &frame->uc.uc_stack.ss_flags); | |
326 | err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size); | |
327 | err |= save_sigregs(regs, &frame->uc.uc_mcontext); | |
328 | err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); | |
329 | if (err) | |
330 | goto give_sigsegv; | |
331 | ||
332 | /* Set up to return from userspace. If provided, use a stub | |
333 | already in userspace. */ | |
334 | if (ka->sa.sa_flags & SA_RESTORER) { | |
335 | regs->gprs[14] = (unsigned long) | |
336 | ka->sa.sa_restorer | PSW_ADDR_AMODE; | |
337 | } else { | |
338 | regs->gprs[14] = (unsigned long) | |
339 | frame->retcode | PSW_ADDR_AMODE; | |
b44df334 HC |
340 | if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, |
341 | (u16 __user *)(frame->retcode))) | |
342 | goto give_sigsegv; | |
1da177e4 LT |
343 | } |
344 | ||
345 | /* Set up backchain. */ | |
346 | if (__put_user(regs->gprs[15], (addr_t __user *) frame)) | |
347 | goto give_sigsegv; | |
348 | ||
349 | /* Set up registers for signal handler */ | |
350 | regs->gprs[15] = (unsigned long) frame; | |
d4e81b35 | 351 | regs->psw.mask |= PSW_MASK_EA | PSW_MASK_BA; /* 64 bit amode */ |
1da177e4 LT |
352 | regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE; |
353 | ||
354 | regs->gprs[2] = map_signal(sig); | |
355 | regs->gprs[3] = (unsigned long) &frame->info; | |
356 | regs->gprs[4] = (unsigned long) &frame->uc; | |
86f2552b | 357 | regs->gprs[5] = task_thread_info(current)->last_break; |
54dfe5dd | 358 | return 0; |
1da177e4 LT |
359 | |
360 | give_sigsegv: | |
361 | force_sigsegv(sig, current); | |
54dfe5dd | 362 | return -EFAULT; |
1da177e4 LT |
363 | } |
364 | ||
a610d6e6 | 365 | static void handle_signal(unsigned long sig, struct k_sigaction *ka, |
391c62fe HC |
366 | siginfo_t *info, sigset_t *oldset, |
367 | struct pt_regs *regs) | |
1da177e4 | 368 | { |
54dfe5dd HC |
369 | int ret; |
370 | ||
1da177e4 LT |
371 | /* Set up the stack frame */ |
372 | if (ka->sa.sa_flags & SA_SIGINFO) | |
54dfe5dd | 373 | ret = setup_rt_frame(sig, ka, info, oldset, regs); |
1da177e4 | 374 | else |
54dfe5dd | 375 | ret = setup_frame(sig, ka, oldset, regs); |
391c62fe | 376 | if (ret) |
a610d6e6 | 377 | return; |
ad252ffa | 378 | block_sigmask(ka, sig); |
a610d6e6 AV |
379 | /* |
380 | * Let tracing know that we've done the handler setup. | |
381 | */ | |
382 | tracehook_signal_handler(sig, info, ka, regs, | |
383 | test_thread_flag(TIF_SINGLE_STEP)); | |
1da177e4 LT |
384 | } |
385 | ||
386 | /* | |
387 | * Note that 'init' is a special process: it doesn't get signals it doesn't | |
388 | * want to handle. Thus you cannot kill init even with a SIGKILL even by | |
389 | * mistake. | |
390 | * | |
391 | * Note that we go through the signals twice: once to check the signals that | |
392 | * the kernel can handle, and then we build all the user-level signal handling | |
393 | * stack-frames in one go after that. | |
394 | */ | |
54dfe5dd | 395 | void do_signal(struct pt_regs *regs) |
1da177e4 | 396 | { |
1da177e4 LT |
397 | siginfo_t info; |
398 | int signr; | |
399 | struct k_sigaction ka; | |
b7f9a11a | 400 | sigset_t *oldset = sigmask_to_save(); |
1da177e4 | 401 | |
20b40a79 MS |
402 | /* |
403 | * Get signal to deliver. When running under ptrace, at this point | |
404 | * the debugger may change all our registers, including the system | |
405 | * call information. | |
406 | */ | |
b6ef5bb3 | 407 | current_thread_info()->system_call = |
aa33c8cb | 408 | test_thread_flag(TIF_SYSCALL) ? regs->int_code : 0; |
1da177e4 | 409 | signr = get_signal_to_deliver(&info, &ka, regs, NULL); |
1da177e4 LT |
410 | |
411 | if (signr > 0) { | |
412 | /* Whee! Actually deliver the signal. */ | |
b6ef5bb3 | 413 | if (current_thread_info()->system_call) { |
aa33c8cb | 414 | regs->int_code = current_thread_info()->system_call; |
20b40a79 MS |
415 | /* Check for system call restarting. */ |
416 | switch (regs->gprs[2]) { | |
417 | case -ERESTART_RESTARTBLOCK: | |
418 | case -ERESTARTNOHAND: | |
419 | regs->gprs[2] = -EINTR; | |
420 | break; | |
421 | case -ERESTARTSYS: | |
422 | if (!(ka.sa.sa_flags & SA_RESTART)) { | |
423 | regs->gprs[2] = -EINTR; | |
424 | break; | |
425 | } | |
426 | /* fallthrough */ | |
427 | case -ERESTARTNOINTR: | |
428 | regs->gprs[2] = regs->orig_gpr2; | |
ccf45caf MS |
429 | regs->psw.addr = |
430 | __rewind_psw(regs->psw, | |
aa33c8cb | 431 | regs->int_code >> 16); |
20b40a79 MS |
432 | break; |
433 | } | |
20b40a79 | 434 | } |
d9ae6772 MS |
435 | /* No longer in a system call */ |
436 | clear_thread_flag(TIF_SYSCALL); | |
20b40a79 | 437 | |
a610d6e6 AV |
438 | if (is_compat_task()) |
439 | handle_signal32(signr, &ka, &info, oldset, regs); | |
440 | else | |
441 | handle_signal(signr, &ka, &info, oldset, regs); | |
54dfe5dd HC |
442 | return; |
443 | } | |
444 | ||
20b40a79 | 445 | /* No handlers present - check for system call restart */ |
d9ae6772 | 446 | clear_thread_flag(TIF_SYSCALL); |
b6ef5bb3 | 447 | if (current_thread_info()->system_call) { |
aa33c8cb | 448 | regs->int_code = current_thread_info()->system_call; |
20b40a79 MS |
449 | switch (regs->gprs[2]) { |
450 | case -ERESTART_RESTARTBLOCK: | |
451 | /* Restart with sys_restart_syscall */ | |
aa33c8cb | 452 | regs->int_code = __NR_restart_syscall; |
20b40a79 MS |
453 | /* fallthrough */ |
454 | case -ERESTARTNOHAND: | |
455 | case -ERESTARTSYS: | |
456 | case -ERESTARTNOINTR: | |
457 | /* Restart system call with magic TIF bit. */ | |
458 | regs->gprs[2] = regs->orig_gpr2; | |
b6ef5bb3 MS |
459 | set_thread_flag(TIF_SYSCALL); |
460 | break; | |
20b40a79 MS |
461 | } |
462 | } | |
463 | ||
54dfe5dd HC |
464 | /* |
465 | * If there's no signal to deliver, we just put the saved sigmask back. | |
466 | */ | |
51a7b448 | 467 | restore_saved_sigmask(); |
1da177e4 | 468 | } |
753c4dd6 MS |
469 | |
470 | void do_notify_resume(struct pt_regs *regs) | |
471 | { | |
472 | clear_thread_flag(TIF_NOTIFY_RESUME); | |
473 | tracehook_notify_resume(regs); | |
474 | } |