1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright IBM Corp. 1999, 2006
4 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
6 * Based on Intel version
8 * Copyright (C) 1991, 1992 Linus Torvalds
10 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
13 #include <linux/sched.h>
14 #include <linux/sched/task_stack.h>
16 #include <linux/smp.h>
17 #include <linux/kernel.h>
18 #include <linux/signal.h>
19 #include <linux/entry-common.h>
20 #include <linux/errno.h>
21 #include <linux/wait.h>
22 #include <linux/ptrace.h>
23 #include <linux/unistd.h>
24 #include <linux/stddef.h>
25 #include <linux/tty.h>
26 #include <linux/personality.h>
27 #include <linux/binfmts.h>
28 #include <linux/tracehook.h>
29 #include <linux/syscalls.h>
30 #include <linux/compat.h>
31 #include <asm/ucontext.h>
32 #include <linux/uaccess.h>
33 #include <asm/lowcore.h>
34 #include <asm/switch_to.h>
38 * Layout of an old-style signal-frame:
39 * -----------------------------------------
40 * | save area (_SIGNAL_FRAMESIZE) |
41 * -----------------------------------------
42 * | struct sigcontext |
45 * -----------------------------------------
47 * | _s390_regs_common |
49 * -----------------------------------------
51 * -----------------------------------------
52 * | _sigregs_ext with |
53 * | gprs_high 64 byte (opt) |
54 * | vxrs_low 128 byte (opt) |
55 * | vxrs_high 256 byte (opt) |
56 * | reserved 128 byte (opt) |
57 * -----------------------------------------
59 * -----------------------------------------
60 * The svc_insn entry with the sigreturn system call opcode does not
61 * have a fixed position and moves if gprs_high or vxrs exist.
62 * Future extensions will be added to _sigregs_ext.
66 __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
70 _sigregs_ext sregs_ext;
71 __u16 svc_insn; /* Offset of svc_insn is NOT fixed! */
75 * Layout of an rt signal-frame:
76 * -----------------------------------------
77 * | save area (_SIGNAL_FRAMESIZE) |
78 * -----------------------------------------
79 * | svc __NR_rt_sigreturn 2 byte |
80 * -----------------------------------------
82 * -----------------------------------------
83 * | struct ucontext_extended with |
84 * | unsigned long uc_flags |
85 * | struct ucontext *uc_link |
86 * | stack_t uc_stack |
87 * | _sigregs uc_mcontext with |
88 * | _s390_regs_common |
90 * | sigset_t uc_sigmask |
91 * | _sigregs_ext uc_mcontext_ext |
92 * | gprs_high 64 byte (opt) |
93 * | vxrs_low 128 byte (opt) |
94 * | vxrs_high 256 byte (opt)|
95 * | reserved 128 byte (opt) |
96 * -----------------------------------------
97 * Future extensions will be added to _sigregs_ext.
101 __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
104 struct ucontext_extended uc;
107 /* Store registers needed to create the signal frame */
108 static void store_sigregs(void)
110 save_access_regs(current->thread.acrs);
114 /* Load registers after signal return */
115 static void load_sigregs(void)
117 restore_access_regs(current->thread.acrs);
120 /* Returns non-zero on fault. */
121 static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
125 /* Copy a 'clean' PSW mask to the user to avoid leaking
126 information about whether PER is currently on. */
127 user_sregs.regs.psw.mask = PSW_USER_BITS |
128 (regs->psw.mask & (PSW_MASK_USER | PSW_MASK_RI));
129 user_sregs.regs.psw.addr = regs->psw.addr;
130 memcpy(&user_sregs.regs.gprs, ®s->gprs, sizeof(sregs->regs.gprs));
131 memcpy(&user_sregs.regs.acrs, current->thread.acrs,
132 sizeof(user_sregs.regs.acrs));
133 fpregs_store(&user_sregs.fpregs, ¤t->thread.fpu);
134 if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs)))
139 static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
143 /* Alwys make any pending restarted system call return -EINTR */
144 current->restart_block.fn = do_no_restart_syscall;
146 if (__copy_from_user(&user_sregs, sregs, sizeof(user_sregs)))
149 if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW_MASK_RI))
152 /* Test the floating-point-control word. */
153 if (test_fp_ctl(user_sregs.fpregs.fpc))
156 /* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */
157 regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | PSW_MASK_RI)) |
158 (user_sregs.regs.psw.mask & (PSW_MASK_USER | PSW_MASK_RI));
159 /* Check for invalid user address space control. */
160 if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME)
161 regs->psw.mask = PSW_ASC_PRIMARY |
162 (regs->psw.mask & ~PSW_MASK_ASC);
163 /* Check for invalid amode */
164 if (regs->psw.mask & PSW_MASK_EA)
165 regs->psw.mask |= PSW_MASK_BA;
166 regs->psw.addr = user_sregs.regs.psw.addr;
167 memcpy(®s->gprs, &user_sregs.regs.gprs, sizeof(sregs->regs.gprs));
168 memcpy(¤t->thread.acrs, &user_sregs.regs.acrs,
169 sizeof(current->thread.acrs));
171 fpregs_load(&user_sregs.fpregs, ¤t->thread.fpu);
173 clear_pt_regs_flag(regs, PIF_SYSCALL); /* No longer in a system call */
174 clear_pt_regs_flag(regs, PIF_SYSCALL_RESTART);
178 /* Returns non-zero on fault. */
179 static int save_sigregs_ext(struct pt_regs *regs,
180 _sigregs_ext __user *sregs_ext)
182 __u64 vxrs[__NUM_VXRS_LOW];
185 /* Save vector registers to signal stack */
186 if (MACHINE_HAS_VX) {
187 for (i = 0; i < __NUM_VXRS_LOW; i++)
188 vxrs[i] = *((__u64 *)(current->thread.fpu.vxrs + i) + 1);
189 if (__copy_to_user(&sregs_ext->vxrs_low, vxrs,
190 sizeof(sregs_ext->vxrs_low)) ||
191 __copy_to_user(&sregs_ext->vxrs_high,
192 current->thread.fpu.vxrs + __NUM_VXRS_LOW,
193 sizeof(sregs_ext->vxrs_high)))
199 static int restore_sigregs_ext(struct pt_regs *regs,
200 _sigregs_ext __user *sregs_ext)
202 __u64 vxrs[__NUM_VXRS_LOW];
205 /* Restore vector registers from signal stack */
206 if (MACHINE_HAS_VX) {
207 if (__copy_from_user(vxrs, &sregs_ext->vxrs_low,
208 sizeof(sregs_ext->vxrs_low)) ||
209 __copy_from_user(current->thread.fpu.vxrs + __NUM_VXRS_LOW,
210 &sregs_ext->vxrs_high,
211 sizeof(sregs_ext->vxrs_high)))
213 for (i = 0; i < __NUM_VXRS_LOW; i++)
214 *((__u64 *)(current->thread.fpu.vxrs + i) + 1) = vxrs[i];
219 SYSCALL_DEFINE0(sigreturn)
221 struct pt_regs *regs = task_pt_regs(current);
222 struct sigframe __user *frame =
223 (struct sigframe __user *) regs->gprs[15];
226 if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE))
228 set_current_blocked(&set);
230 if (restore_sigregs(regs, &frame->sregs))
232 if (restore_sigregs_ext(regs, &frame->sregs_ext))
235 return regs->gprs[2];
241 SYSCALL_DEFINE0(rt_sigreturn)
243 struct pt_regs *regs = task_pt_regs(current);
244 struct rt_sigframe __user *frame =
245 (struct rt_sigframe __user *)regs->gprs[15];
248 if (__copy_from_user(&set.sig, &frame->uc.uc_sigmask, sizeof(set)))
250 set_current_blocked(&set);
251 if (restore_altstack(&frame->uc.uc_stack))
254 if (restore_sigregs(regs, &frame->uc.uc_mcontext))
256 if (restore_sigregs_ext(regs, &frame->uc.uc_mcontext_ext))
259 return regs->gprs[2];
266 * Determine which stack to use..
268 static inline void __user *
269 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
273 /* Default to using normal stack */
276 /* Overflow on alternate signal stack gives SIGSEGV. */
277 if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
278 return (void __user *) -1UL;
280 /* This is the X/Open sanctioned signal stack switching. */
281 if (ka->sa.sa_flags & SA_ONSTACK) {
282 if (! sas_ss_flags(sp))
283 sp = current->sas_ss_sp + current->sas_ss_size;
286 return (void __user *)((sp - frame_size) & -8ul);
289 static int setup_frame(int sig, struct k_sigaction *ka,
290 sigset_t *set, struct pt_regs * regs)
292 struct sigframe __user *frame;
293 struct sigcontext sc;
294 unsigned long restorer;
298 * gprs_high are only present for a 31-bit task running on
299 * a 64-bit kernel (see compat_signal.c) but the space for
300 * gprs_high need to be allocated if vector registers are
301 * included in the signal frame on a 31-bit system.
303 frame_size = sizeof(*frame) - sizeof(frame->sregs_ext);
305 frame_size += sizeof(frame->sregs_ext);
306 frame = get_sigframe(ka, regs, frame_size);
307 if (frame == (void __user *) -1UL)
310 /* Set up backchain. */
311 if (__put_user(regs->gprs[15], (addr_t __user *) frame))
314 /* Create struct sigcontext on the signal stack */
315 memcpy(&sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE);
316 sc.sregs = (_sigregs __user __force *) &frame->sregs;
317 if (__copy_to_user(&frame->sc, &sc, sizeof(frame->sc)))
320 /* Store registers needed to create the signal frame */
323 /* Create _sigregs on the signal stack */
324 if (save_sigregs(regs, &frame->sregs))
327 /* Place signal number on stack to allow backtrace from handler. */
328 if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
331 /* Create _sigregs_ext on the signal stack */
332 if (save_sigregs_ext(regs, &frame->sregs_ext))
335 /* Set up to return from userspace. If provided, use a stub
336 already in userspace. */
337 if (ka->sa.sa_flags & SA_RESTORER) {
338 restorer = (unsigned long) ka->sa.sa_restorer;
340 /* Signal frame without vector registers are short ! */
341 __u16 __user *svc = (void __user *) frame + frame_size - 2;
342 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, svc))
344 restorer = (unsigned long) svc;
347 /* Set up registers for signal handler */
348 regs->gprs[14] = restorer;
349 regs->gprs[15] = (unsigned long) frame;
350 /* Force default amode and default user address space control. */
351 regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA |
352 (PSW_USER_BITS & PSW_MASK_ASC) |
353 (regs->psw.mask & ~PSW_MASK_ASC);
354 regs->psw.addr = (unsigned long) ka->sa.sa_handler;
357 regs->gprs[3] = (unsigned long) &frame->sc;
359 /* We forgot to include these in the sigcontext.
360 To avoid breaking binary compatibility, they are passed as args. */
361 if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
362 sig == SIGTRAP || sig == SIGFPE) {
363 /* set extra registers only for synchronous signals */
364 regs->gprs[4] = regs->int_code & 127;
365 regs->gprs[5] = regs->int_parm_long;
366 regs->gprs[6] = current->thread.last_break;
371 static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
372 struct pt_regs *regs)
374 struct rt_sigframe __user *frame;
375 unsigned long uc_flags, restorer;
378 frame_size = sizeof(struct rt_sigframe) - sizeof(_sigregs_ext);
380 * gprs_high are only present for a 31-bit task running on
381 * a 64-bit kernel (see compat_signal.c) but the space for
382 * gprs_high need to be allocated if vector registers are
383 * included in the signal frame on a 31-bit system.
386 if (MACHINE_HAS_VX) {
387 frame_size += sizeof(_sigregs_ext);
390 frame = get_sigframe(&ksig->ka, regs, frame_size);
391 if (frame == (void __user *) -1UL)
394 /* Set up backchain. */
395 if (__put_user(regs->gprs[15], (addr_t __user *) frame))
398 /* Set up to return from userspace. If provided, use a stub
399 already in userspace. */
400 if (ksig->ka.sa.sa_flags & SA_RESTORER) {
401 restorer = (unsigned long) ksig->ka.sa.sa_restorer;
403 __u16 __user *svc = &frame->svc_insn;
404 if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, svc))
406 restorer = (unsigned long) svc;
409 /* Create siginfo on the signal stack */
410 if (copy_siginfo_to_user(&frame->info, &ksig->info))
413 /* Store registers needed to create the signal frame */
416 /* Create ucontext on the signal stack. */
417 if (__put_user(uc_flags, &frame->uc.uc_flags) ||
418 __put_user(NULL, &frame->uc.uc_link) ||
419 __save_altstack(&frame->uc.uc_stack, regs->gprs[15]) ||
420 save_sigregs(regs, &frame->uc.uc_mcontext) ||
421 __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)) ||
422 save_sigregs_ext(regs, &frame->uc.uc_mcontext_ext))
425 /* Set up registers for signal handler */
426 regs->gprs[14] = restorer;
427 regs->gprs[15] = (unsigned long) frame;
428 /* Force default amode and default user address space control. */
429 regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA |
430 (PSW_USER_BITS & PSW_MASK_ASC) |
431 (regs->psw.mask & ~PSW_MASK_ASC);
432 regs->psw.addr = (unsigned long) ksig->ka.sa.sa_handler;
434 regs->gprs[2] = ksig->sig;
435 regs->gprs[3] = (unsigned long) &frame->info;
436 regs->gprs[4] = (unsigned long) &frame->uc;
437 regs->gprs[5] = current->thread.last_break;
441 static void handle_signal(struct ksignal *ksig, sigset_t *oldset,
442 struct pt_regs *regs)
446 /* Set up the stack frame */
447 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
448 ret = setup_rt_frame(ksig, oldset, regs);
450 ret = setup_frame(ksig->sig, &ksig->ka, oldset, regs);
452 signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP));
456 * Note that 'init' is a special process: it doesn't get signals it doesn't
457 * want to handle. Thus you cannot kill init even with a SIGKILL even by
460 * Note that we go through the signals twice: once to check the signals that
461 * the kernel can handle, and then we build all the user-level signal handling
462 * stack-frames in one go after that.
465 void arch_do_signal_or_restart(struct pt_regs *regs, bool has_signal)
468 sigset_t *oldset = sigmask_to_save();
471 * Get signal to deliver. When running under ptrace, at this point
472 * the debugger may change all our registers, including the system
475 current->thread.system_call =
476 test_pt_regs_flag(regs, PIF_SYSCALL) ? regs->int_code : 0;
478 if (has_signal && get_signal(&ksig)) {
479 /* Whee! Actually deliver the signal. */
480 if (current->thread.system_call) {
481 regs->int_code = current->thread.system_call;
482 /* Check for system call restarting. */
483 switch (regs->gprs[2]) {
484 case -ERESTART_RESTARTBLOCK:
485 case -ERESTARTNOHAND:
486 regs->gprs[2] = -EINTR;
489 if (!(ksig.ka.sa.sa_flags & SA_RESTART)) {
490 regs->gprs[2] = -EINTR;
494 case -ERESTARTNOINTR:
495 regs->gprs[2] = regs->orig_gpr2;
497 __rewind_psw(regs->psw,
498 regs->int_code >> 16);
502 /* No longer in a system call */
503 clear_pt_regs_flag(regs, PIF_SYSCALL);
504 clear_pt_regs_flag(regs, PIF_SYSCALL_RESTART);
505 rseq_signal_deliver(&ksig, regs);
506 if (is_compat_task())
507 handle_signal32(&ksig, oldset, regs);
509 handle_signal(&ksig, oldset, regs);
513 /* No handlers present - check for system call restart */
514 clear_pt_regs_flag(regs, PIF_SYSCALL);
515 clear_pt_regs_flag(regs, PIF_SYSCALL_RESTART);
516 if (current->thread.system_call) {
517 regs->int_code = current->thread.system_call;
518 switch (regs->gprs[2]) {
519 case -ERESTART_RESTARTBLOCK:
520 /* Restart with sys_restart_syscall */
521 regs->int_code = __NR_restart_syscall;
523 case -ERESTARTNOHAND:
525 case -ERESTARTNOINTR:
526 /* Restart system call with magic TIF bit. */
527 regs->gprs[2] = regs->orig_gpr2;
528 set_pt_regs_flag(regs, PIF_SYSCALL_RESTART);
529 if (test_thread_flag(TIF_SINGLE_STEP))
530 clear_thread_flag(TIF_PER_TRAP);
536 * If there's no signal to deliver, we just put the saved sigmask back.
538 restore_saved_sigmask();
541 void do_notify_resume(struct pt_regs *regs)
543 tracehook_notify_resume(regs);
544 rseq_handle_notify_resume(NULL, regs);