2 * arch/s390/kernel/signal.c
4 * Copyright (C) IBM Corp. 1999,2006
5 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
7 * Based on Intel version
9 * Copyright (C) 1991, 1992 Linus Torvalds
11 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
14 #include <linux/sched.h>
16 #include <linux/smp.h>
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>
27 #include <linux/tracehook.h>
28 #include <linux/syscalls.h>
29 #include <linux/compat.h>
30 #include <asm/ucontext.h>
31 #include <asm/uaccess.h>
32 #include <asm/lowcore.h>
33 #include <asm/compat.h>
36 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
41 __u8 callee_used_stack
[__SIGNAL_FRAMESIZE
];
45 __u8 retcode
[S390_SYSCALL_SIZE
];
50 __u8 callee_used_stack
[__SIGNAL_FRAMESIZE
];
51 __u8 retcode
[S390_SYSCALL_SIZE
];
57 * Atomically swap in the new signal mask, and wait for a signal.
59 SYSCALL_DEFINE3(sigsuspend
, int, history0
, int, history1
, old_sigset_t
, mask
)
63 current
->saved_sigmask
= current
->blocked
;
65 siginitset(&blocked
, mask
);
66 set_current_blocked(&blocked
);
67 set_current_state(TASK_INTERRUPTIBLE
);
69 set_restore_sigmask();
70 return -ERESTARTNOHAND
;
73 SYSCALL_DEFINE3(sigaction
, int, sig
, const struct old_sigaction __user
*, act
,
74 struct old_sigaction __user
*, oact
)
76 struct k_sigaction new_ka
, old_ka
;
81 if (!access_ok(VERIFY_READ
, act
, sizeof(*act
)) ||
82 __get_user(new_ka
.sa
.sa_handler
, &act
->sa_handler
) ||
83 __get_user(new_ka
.sa
.sa_restorer
, &act
->sa_restorer
) ||
84 __get_user(new_ka
.sa
.sa_flags
, &act
->sa_flags
) ||
85 __get_user(mask
, &act
->sa_mask
))
87 siginitset(&new_ka
.sa
.sa_mask
, mask
);
90 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
93 if (!access_ok(VERIFY_WRITE
, oact
, sizeof(*oact
)) ||
94 __put_user(old_ka
.sa
.sa_handler
, &oact
->sa_handler
) ||
95 __put_user(old_ka
.sa
.sa_restorer
, &oact
->sa_restorer
) ||
96 __put_user(old_ka
.sa
.sa_flags
, &oact
->sa_flags
) ||
97 __put_user(old_ka
.sa
.sa_mask
.sig
[0], &oact
->sa_mask
))
104 SYSCALL_DEFINE2(sigaltstack
, const stack_t __user
*, uss
,
105 stack_t __user
*, uoss
)
107 struct pt_regs
*regs
= task_pt_regs(current
);
108 return do_sigaltstack(uss
, uoss
, regs
->gprs
[15]);
111 /* Returns non-zero on fault. */
112 static int save_sigregs(struct pt_regs
*regs
, _sigregs __user
*sregs
)
116 save_access_regs(current
->thread
.acrs
);
118 /* Copy a 'clean' PSW mask to the user to avoid leaking
119 information about whether PER is currently on. */
120 user_sregs
.regs
.psw
.mask
= psw_user_bits
|
121 (regs
->psw
.mask
& PSW_MASK_USER
);
122 user_sregs
.regs
.psw
.addr
= regs
->psw
.addr
;
123 memcpy(&user_sregs
.regs
.gprs
, ®s
->gprs
, sizeof(sregs
->regs
.gprs
));
124 memcpy(&user_sregs
.regs
.acrs
, current
->thread
.acrs
,
125 sizeof(sregs
->regs
.acrs
));
127 * We have to store the fp registers to current->thread.fp_regs
128 * to merge them with the emulated registers.
130 save_fp_regs(¤t
->thread
.fp_regs
);
131 memcpy(&user_sregs
.fpregs
, ¤t
->thread
.fp_regs
,
132 sizeof(s390_fp_regs
));
133 return __copy_to_user(sregs
, &user_sregs
, sizeof(_sigregs
));
136 /* Returns positive number on error */
137 static int restore_sigregs(struct pt_regs
*regs
, _sigregs __user
*sregs
)
142 /* Alwys make any pending restarted system call return -EINTR */
143 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
145 err
= __copy_from_user(&user_sregs
, sregs
, sizeof(_sigregs
));
148 /* Use regs->psw.mask instead of psw_user_bits to preserve PER bit. */
149 regs
->psw
.mask
= (regs
->psw
.mask
& ~PSW_MASK_USER
) |
150 (user_sregs
.regs
.psw
.mask
& PSW_MASK_USER
);
151 /* Check for invalid amode */
152 if (regs
->psw
.mask
& PSW_MASK_EA
)
153 regs
->psw
.mask
|= PSW_MASK_BA
;
154 regs
->psw
.addr
= user_sregs
.regs
.psw
.addr
;
155 memcpy(®s
->gprs
, &user_sregs
.regs
.gprs
, sizeof(sregs
->regs
.gprs
));
156 memcpy(¤t
->thread
.acrs
, &user_sregs
.regs
.acrs
,
157 sizeof(sregs
->regs
.acrs
));
158 restore_access_regs(current
->thread
.acrs
);
160 memcpy(¤t
->thread
.fp_regs
, &user_sregs
.fpregs
,
161 sizeof(s390_fp_regs
));
162 current
->thread
.fp_regs
.fpc
&= FPC_VALID_MASK
;
164 restore_fp_regs(¤t
->thread
.fp_regs
);
165 clear_thread_flag(TIF_SYSCALL
); /* No longer in a system call */
169 SYSCALL_DEFINE0(sigreturn
)
171 struct pt_regs
*regs
= task_pt_regs(current
);
172 sigframe __user
*frame
= (sigframe __user
*)regs
->gprs
[15];
175 if (!access_ok(VERIFY_READ
, frame
, sizeof(*frame
)))
177 if (__copy_from_user(&set
.sig
, &frame
->sc
.oldmask
, _SIGMASK_COPY_SIZE
))
179 sigdelsetmask(&set
, ~_BLOCKABLE
);
180 set_current_blocked(&set
);
181 if (restore_sigregs(regs
, &frame
->sregs
))
183 return regs
->gprs
[2];
185 force_sig(SIGSEGV
, current
);
189 SYSCALL_DEFINE0(rt_sigreturn
)
191 struct pt_regs
*regs
= task_pt_regs(current
);
192 rt_sigframe __user
*frame
= (rt_sigframe __user
*)regs
->gprs
[15];
195 if (!access_ok(VERIFY_READ
, frame
, sizeof(*frame
)))
197 if (__copy_from_user(&set
.sig
, &frame
->uc
.uc_sigmask
, sizeof(set
)))
199 sigdelsetmask(&set
, ~_BLOCKABLE
);
200 set_current_blocked(&set
);
201 if (restore_sigregs(regs
, &frame
->uc
.uc_mcontext
))
203 if (do_sigaltstack(&frame
->uc
.uc_stack
, NULL
,
204 regs
->gprs
[15]) == -EFAULT
)
206 return regs
->gprs
[2];
208 force_sig(SIGSEGV
, current
);
213 * Set up a signal frame.
218 * Determine which stack to use..
220 static inline void __user
*
221 get_sigframe(struct k_sigaction
*ka
, struct pt_regs
* regs
, size_t frame_size
)
225 /* Default to using normal stack */
228 /* Overflow on alternate signal stack gives SIGSEGV. */
229 if (on_sig_stack(sp
) && !on_sig_stack((sp
- frame_size
) & -8UL))
230 return (void __user
*) -1UL;
232 /* This is the X/Open sanctioned signal stack switching. */
233 if (ka
->sa
.sa_flags
& SA_ONSTACK
) {
234 if (! sas_ss_flags(sp
))
235 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
238 /* This is the legacy signal stack switching. */
239 else if (!user_mode(regs
) &&
240 !(ka
->sa
.sa_flags
& SA_RESTORER
) &&
241 ka
->sa
.sa_restorer
) {
242 sp
= (unsigned long) ka
->sa
.sa_restorer
;
245 return (void __user
*)((sp
- frame_size
) & -8ul);
248 static inline int map_signal(int sig
)
250 if (current_thread_info()->exec_domain
251 && current_thread_info()->exec_domain
->signal_invmap
253 return current_thread_info()->exec_domain
->signal_invmap
[sig
];
258 static int setup_frame(int sig
, struct k_sigaction
*ka
,
259 sigset_t
*set
, struct pt_regs
* regs
)
261 sigframe __user
*frame
;
263 frame
= get_sigframe(ka
, regs
, sizeof(sigframe
));
264 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(sigframe
)))
267 if (frame
== (void __user
*) -1UL)
270 if (__copy_to_user(&frame
->sc
.oldmask
, &set
->sig
, _SIGMASK_COPY_SIZE
))
273 if (save_sigregs(regs
, &frame
->sregs
))
275 if (__put_user(&frame
->sregs
, &frame
->sc
.sregs
))
278 /* Set up to return from userspace. If provided, use a stub
279 already in userspace. */
280 if (ka
->sa
.sa_flags
& SA_RESTORER
) {
281 regs
->gprs
[14] = (unsigned long)
282 ka
->sa
.sa_restorer
| PSW_ADDR_AMODE
;
284 regs
->gprs
[14] = (unsigned long)
285 frame
->retcode
| PSW_ADDR_AMODE
;
286 if (__put_user(S390_SYSCALL_OPCODE
| __NR_sigreturn
,
287 (u16 __user
*)(frame
->retcode
)))
291 /* Set up backchain. */
292 if (__put_user(regs
->gprs
[15], (addr_t __user
*) frame
))
295 /* Set up registers for signal handler */
296 regs
->gprs
[15] = (unsigned long) frame
;
297 regs
->psw
.mask
|= PSW_MASK_EA
| PSW_MASK_BA
; /* 64 bit amode */
298 regs
->psw
.addr
= (unsigned long) ka
->sa
.sa_handler
| PSW_ADDR_AMODE
;
300 regs
->gprs
[2] = map_signal(sig
);
301 regs
->gprs
[3] = (unsigned long) &frame
->sc
;
303 /* We forgot to include these in the sigcontext.
304 To avoid breaking binary compatibility, they are passed as args. */
305 if (sig
== SIGSEGV
|| sig
== SIGBUS
|| sig
== SIGILL
||
306 sig
== SIGTRAP
|| sig
== SIGFPE
) {
307 /* set extra registers only for synchronous signals */
308 regs
->gprs
[4] = regs
->int_code
& 127;
309 regs
->gprs
[5] = regs
->int_parm_long
;
310 regs
->gprs
[6] = task_thread_info(current
)->last_break
;
313 /* Place signal number on stack to allow backtrace from handler. */
314 if (__put_user(regs
->gprs
[2], (int __user
*) &frame
->signo
))
319 force_sigsegv(sig
, current
);
323 static int setup_rt_frame(int sig
, struct k_sigaction
*ka
, siginfo_t
*info
,
324 sigset_t
*set
, struct pt_regs
* regs
)
327 rt_sigframe __user
*frame
;
329 frame
= get_sigframe(ka
, regs
, sizeof(rt_sigframe
));
330 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(rt_sigframe
)))
333 if (frame
== (void __user
*) -1UL)
336 if (copy_siginfo_to_user(&frame
->info
, info
))
339 /* Create the ucontext. */
340 err
|= __put_user(0, &frame
->uc
.uc_flags
);
341 err
|= __put_user(NULL
, &frame
->uc
.uc_link
);
342 err
|= __put_user((void __user
*)current
->sas_ss_sp
, &frame
->uc
.uc_stack
.ss_sp
);
343 err
|= __put_user(sas_ss_flags(regs
->gprs
[15]),
344 &frame
->uc
.uc_stack
.ss_flags
);
345 err
|= __put_user(current
->sas_ss_size
, &frame
->uc
.uc_stack
.ss_size
);
346 err
|= save_sigregs(regs
, &frame
->uc
.uc_mcontext
);
347 err
|= __copy_to_user(&frame
->uc
.uc_sigmask
, set
, sizeof(*set
));
351 /* Set up to return from userspace. If provided, use a stub
352 already in userspace. */
353 if (ka
->sa
.sa_flags
& SA_RESTORER
) {
354 regs
->gprs
[14] = (unsigned long)
355 ka
->sa
.sa_restorer
| PSW_ADDR_AMODE
;
357 regs
->gprs
[14] = (unsigned long)
358 frame
->retcode
| PSW_ADDR_AMODE
;
359 if (__put_user(S390_SYSCALL_OPCODE
| __NR_rt_sigreturn
,
360 (u16 __user
*)(frame
->retcode
)))
364 /* Set up backchain. */
365 if (__put_user(regs
->gprs
[15], (addr_t __user
*) frame
))
368 /* Set up registers for signal handler */
369 regs
->gprs
[15] = (unsigned long) frame
;
370 regs
->psw
.mask
|= PSW_MASK_EA
| PSW_MASK_BA
; /* 64 bit amode */
371 regs
->psw
.addr
= (unsigned long) ka
->sa
.sa_handler
| PSW_ADDR_AMODE
;
373 regs
->gprs
[2] = map_signal(sig
);
374 regs
->gprs
[3] = (unsigned long) &frame
->info
;
375 regs
->gprs
[4] = (unsigned long) &frame
->uc
;
376 regs
->gprs
[5] = task_thread_info(current
)->last_break
;
380 force_sigsegv(sig
, current
);
384 static int handle_signal(unsigned long sig
, struct k_sigaction
*ka
,
385 siginfo_t
*info
, sigset_t
*oldset
,
386 struct pt_regs
*regs
)
391 /* Set up the stack frame */
392 if (ka
->sa
.sa_flags
& SA_SIGINFO
)
393 ret
= setup_rt_frame(sig
, ka
, info
, oldset
, regs
);
395 ret
= setup_frame(sig
, ka
, oldset
, regs
);
398 sigorsets(&blocked
, ¤t
->blocked
, &ka
->sa
.sa_mask
);
399 if (!(ka
->sa
.sa_flags
& SA_NODEFER
))
400 sigaddset(&blocked
, sig
);
401 set_current_blocked(&blocked
);
406 * Note that 'init' is a special process: it doesn't get signals it doesn't
407 * want to handle. Thus you cannot kill init even with a SIGKILL even by
410 * Note that we go through the signals twice: once to check the signals that
411 * the kernel can handle, and then we build all the user-level signal handling
412 * stack-frames in one go after that.
414 void do_signal(struct pt_regs
*regs
)
418 struct k_sigaction ka
;
422 * We want the common case to go fast, which
423 * is why we may in certain cases get here from
424 * kernel mode. Just return without doing anything
427 if (!user_mode(regs
))
430 if (test_thread_flag(TIF_RESTORE_SIGMASK
))
431 oldset
= ¤t
->saved_sigmask
;
433 oldset
= ¤t
->blocked
;
436 * Get signal to deliver. When running under ptrace, at this point
437 * the debugger may change all our registers, including the system
440 current_thread_info()->system_call
=
441 test_thread_flag(TIF_SYSCALL
) ? regs
->int_code
: 0;
442 signr
= get_signal_to_deliver(&info
, &ka
, regs
, NULL
);
445 /* Whee! Actually deliver the signal. */
446 if (current_thread_info()->system_call
) {
447 regs
->int_code
= current_thread_info()->system_call
;
448 /* Check for system call restarting. */
449 switch (regs
->gprs
[2]) {
450 case -ERESTART_RESTARTBLOCK
:
451 case -ERESTARTNOHAND
:
452 regs
->gprs
[2] = -EINTR
;
455 if (!(ka
.sa
.sa_flags
& SA_RESTART
)) {
456 regs
->gprs
[2] = -EINTR
;
460 case -ERESTARTNOINTR
:
461 regs
->gprs
[2] = regs
->orig_gpr2
;
463 __rewind_psw(regs
->psw
,
464 regs
->int_code
>> 16);
468 /* No longer in a system call */
469 clear_thread_flag(TIF_SYSCALL
);
471 if ((is_compat_task() ?
472 handle_signal32(signr
, &ka
, &info
, oldset
, regs
) :
473 handle_signal(signr
, &ka
, &info
, oldset
, regs
)) == 0) {
475 * A signal was successfully delivered; the saved
476 * sigmask will have been stored in the signal frame,
477 * and will be restored by sigreturn, so we can simply
478 * clear the TIF_RESTORE_SIGMASK flag.
480 if (test_thread_flag(TIF_RESTORE_SIGMASK
))
481 clear_thread_flag(TIF_RESTORE_SIGMASK
);
484 * Let tracing know that we've done the handler setup.
486 tracehook_signal_handler(signr
, &info
, &ka
, regs
,
487 test_thread_flag(TIF_SINGLE_STEP
));
492 /* No handlers present - check for system call restart */
493 clear_thread_flag(TIF_SYSCALL
);
494 if (current_thread_info()->system_call
) {
495 regs
->int_code
= current_thread_info()->system_call
;
496 switch (regs
->gprs
[2]) {
497 case -ERESTART_RESTARTBLOCK
:
498 /* Restart with sys_restart_syscall */
499 regs
->int_code
= __NR_restart_syscall
;
501 case -ERESTARTNOHAND
:
503 case -ERESTARTNOINTR
:
504 /* Restart system call with magic TIF bit. */
505 regs
->gprs
[2] = regs
->orig_gpr2
;
506 set_thread_flag(TIF_SYSCALL
);
512 * If there's no signal to deliver, we just put the saved sigmask back.
514 if (test_thread_flag(TIF_RESTORE_SIGMASK
)) {
515 clear_thread_flag(TIF_RESTORE_SIGMASK
);
516 sigprocmask(SIG_SETMASK
, ¤t
->saved_sigmask
, NULL
);
520 void do_notify_resume(struct pt_regs
*regs
)
522 clear_thread_flag(TIF_NOTIFY_RESUME
);
523 tracehook_notify_resume(regs
);
524 if (current
->replacement_session_keyring
)
525 key_replace_session_keyring();