1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright IBM Corp. 1999, 2006
4 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
5 *
6 * Based on Intel version
7 *
8 * Copyright (C) 1991, 1992 Linus Torvalds
9 *
10 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
11 */
12
13#include <linux/sched.h>
14#include <linux/sched/task_stack.h>
15#include <linux/rseq.h>
16#include <linux/mm.h>
17#include <linux/smp.h>
18#include <linux/kernel.h>
19#include <linux/signal.h>
20#include <linux/entry-common.h>
21#include <linux/errno.h>
22#include <linux/wait.h>
23#include <linux/ptrace.h>
24#include <linux/unistd.h>
25#include <linux/stddef.h>
26#include <linux/tty.h>
27#include <linux/personality.h>
28#include <linux/binfmts.h>
29#include <linux/syscalls.h>
30#include <asm/ucontext.h>
31#include <linux/uaccess.h>
32#include <asm/vdso-symbols.h>
33#include <asm/access-regs.h>
34#include <asm/lowcore.h>
35#include "entry.h"
36
37/*
38 * Layout of an old-style signal-frame:
39 * -----------------------------------------
40 * | save area (_SIGNAL_FRAMESIZE) |
41 * -----------------------------------------
42 * | struct sigcontext |
43 * | oldmask |
44 * | _sigregs * |
45 * -----------------------------------------
46 * | _sigregs with |
47 * | _s390_regs_common |
48 * | _s390_fp_regs |
49 * -----------------------------------------
50 * | int signo |
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 * -----------------------------------------
58 * | __u16 svc_insn |
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.
63 */
64struct sigframe
65{
66 __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
67 struct sigcontext sc;
68 _sigregs sregs;
69 int signo;
70 _sigregs_ext sregs_ext;
71 __u16 svc_insn; /* Offset of svc_insn is NOT fixed! */
72};
73
74/*
75 * Layout of an rt signal-frame:
76 * -----------------------------------------
77 * | save area (_SIGNAL_FRAMESIZE) |
78 * -----------------------------------------
79 * | svc __NR_rt_sigreturn 2 byte |
80 * -----------------------------------------
81 * | struct siginfo |
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 |
89 * | _s390_fp_regs |
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.
98 */
99struct rt_sigframe
100{
101 __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
102 __u16 svc_insn;
103 struct siginfo info;
104 struct ucontext_extended uc;
105};
106
107/* Store registers needed to create the signal frame */
108static void store_sigregs(void)
109{
110 save_access_regs(current->thread.acrs);
111 save_user_fpu_regs();
112}
113
114/* Load registers after signal return */
115static void load_sigregs(void)
116{
117 restore_access_regs(current->thread.acrs);
118}
119
120/* Returns non-zero on fault. */
121static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
122{
123 _sigregs user_sregs;
124
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, &regs->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, &current->thread.ufpu);
134 if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs)))
135 return -EFAULT;
136 return 0;
137}
138
139static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
140{
141 _sigregs user_sregs;
142
143 /* Always make any pending restarted system call return -EINTR */
144 current->restart_block.fn = do_no_restart_syscall;
145
146 if (__copy_from_user(to: &user_sregs, from: sregs, n: sizeof(user_sregs)))
147 return -EFAULT;
148
149 if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW_MASK_RI))
150 return -EINVAL;
151
152 /* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */
153 regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | PSW_MASK_RI)) |
154 (user_sregs.regs.psw.mask & (PSW_MASK_USER | PSW_MASK_RI));
155 /* Check for invalid user address space control. */
156 if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME)
157 regs->psw.mask = PSW_ASC_PRIMARY |
158 (regs->psw.mask & ~PSW_MASK_ASC);
159 /* Check for invalid amode */
160 if (regs->psw.mask & PSW_MASK_EA)
161 regs->psw.mask |= PSW_MASK_BA;
162 regs->psw.addr = user_sregs.regs.psw.addr;
163 memcpy(&regs->gprs, &user_sregs.regs.gprs, sizeof(sregs->regs.gprs));
164 memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
165 sizeof(current->thread.acrs));
166
167 fpregs_load(&user_sregs.fpregs, &current->thread.ufpu);
168
169 clear_pt_regs_flag(regs, PIF_SYSCALL); /* No longer in a system call */
170 return 0;
171}
172
173/* Returns non-zero on fault. */
174static int save_sigregs_ext(struct pt_regs *regs,
175 _sigregs_ext __user *sregs_ext)
176{
177 __u64 vxrs[__NUM_VXRS_LOW];
178 int i;
179
180 /* Save vector registers to signal stack */
181 if (cpu_has_vx()) {
182 for (i = 0; i < __NUM_VXRS_LOW; i++)
183 vxrs[i] = current->thread.ufpu.vxrs[i].low;
184 if (__copy_to_user(&sregs_ext->vxrs_low, vxrs,
185 sizeof(sregs_ext->vxrs_low)) ||
186 __copy_to_user(&sregs_ext->vxrs_high,
187 current->thread.ufpu.vxrs + __NUM_VXRS_LOW,
188 sizeof(sregs_ext->vxrs_high)))
189 return -EFAULT;
190 }
191 return 0;
192}
193
194static int restore_sigregs_ext(struct pt_regs *regs,
195 _sigregs_ext __user *sregs_ext)
196{
197 __u64 vxrs[__NUM_VXRS_LOW];
198 int i;
199
200 /* Restore vector registers from signal stack */
201 if (cpu_has_vx()) {
202 if (__copy_from_user(vxrs, &sregs_ext->vxrs_low,
203 sizeof(sregs_ext->vxrs_low)) ||
204 __copy_from_user(current->thread.ufpu.vxrs + __NUM_VXRS_LOW,
205 &sregs_ext->vxrs_high,
206 sizeof(sregs_ext->vxrs_high)))
207 return -EFAULT;
208 for (i = 0; i < __NUM_VXRS_LOW; i++)
209 current->thread.ufpu.vxrs[i].low = vxrs[i];
210 }
211 return 0;
212}
213
214SYSCALL_DEFINE0(sigreturn)
215{
216 struct pt_regs *regs = task_pt_regs(current);
217 struct sigframe __user *frame =
218 (struct sigframe __user *) regs->gprs[15];
219 sigset_t set;
220
221 if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE))
222 goto badframe;
223 set_current_blocked(&set);
224 save_user_fpu_regs();
225 if (restore_sigregs(regs, &frame->sregs))
226 goto badframe;
227 if (restore_sigregs_ext(regs, &frame->sregs_ext))
228 goto badframe;
229 load_sigregs();
230 return regs->gprs[2];
231badframe:
232 force_sig(SIGSEGV);
233 return 0;
234}
235
236SYSCALL_DEFINE0(rt_sigreturn)
237{
238 struct pt_regs *regs = task_pt_regs(current);
239 struct rt_sigframe __user *frame =
240 (struct rt_sigframe __user *)regs->gprs[15];
241 sigset_t set;
242
243 if (__copy_from_user(to: &set.sig, from: &frame->uc.uc_sigmask, n: sizeof(set)))
244 goto badframe;
245 set_current_blocked(&set);
246 if (restore_altstack(&frame->uc.uc_stack))
247 goto badframe;
248 save_user_fpu_regs();
249 if (restore_sigregs(regs, &frame->uc.uc_mcontext))
250 goto badframe;
251 if (restore_sigregs_ext(regs, &frame->uc.uc_mcontext_ext))
252 goto badframe;
253 load_sigregs();
254 return regs->gprs[2];
255badframe:
256 force_sig(SIGSEGV);
257 return 0;
258}
259
260/*
261 * Determine which stack to use..
262 */
263static inline void __user *
264get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
265{
266 unsigned long sp;
267
268 /* Default to using normal stack */
269 sp = regs->gprs[15];
270
271 /* Overflow on alternate signal stack gives SIGSEGV. */
272 if (on_sig_stack(sp) && !on_sig_stack(sp: (sp - frame_size) & -8UL))
273 return (void __user *) -1UL;
274
275 /* This is the X/Open sanctioned signal stack switching. */
276 if (ka->sa.sa_flags & SA_ONSTACK) {
277 if (! sas_ss_flags(sp))
278 sp = current->sas_ss_sp + current->sas_ss_size;
279 }
280
281 return (void __user *)((sp - frame_size) & -8ul);
282}
283
284static int setup_frame(int sig, struct k_sigaction *ka,
285 sigset_t *set, struct pt_regs * regs)
286{
287 struct sigframe __user *frame;
288 struct sigcontext sc;
289 unsigned long restorer;
290 size_t frame_size;
291
292 frame_size = sizeof(*frame) - sizeof(frame->sregs_ext);
293 if (cpu_has_vx())
294 frame_size += sizeof(frame->sregs_ext);
295 frame = get_sigframe(ka, regs, frame_size);
296 if (frame == (void __user *) -1UL)
297 return -EFAULT;
298
299 /* Set up backchain. */
300 if (__put_user(regs->gprs[15], (addr_t __user *) frame))
301 return -EFAULT;
302
303 /* Create struct sigcontext on the signal stack */
304 memcpy(&sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE);
305 sc.sregs = (_sigregs __user __force *) &frame->sregs;
306 if (__copy_to_user(to: &frame->sc, from: &sc, n: sizeof(frame->sc)))
307 return -EFAULT;
308
309 /* Store registers needed to create the signal frame */
310 store_sigregs();
311
312 /* Create _sigregs on the signal stack */
313 if (save_sigregs(regs, &frame->sregs))
314 return -EFAULT;
315
316 /* Place signal number on stack to allow backtrace from handler. */
317 if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
318 return -EFAULT;
319
320 /* Create _sigregs_ext on the signal stack */
321 if (save_sigregs_ext(regs, &frame->sregs_ext))
322 return -EFAULT;
323
324 /* Set up to return from userspace. If provided, use a stub
325 already in userspace. */
326 if (ka->sa.sa_flags & SA_RESTORER)
327 restorer = (unsigned long) ka->sa.sa_restorer;
328 else
329 restorer = VDSO_SYMBOL(current, sigreturn);
330
331 /* Set up registers for signal handler */
332 regs->gprs[14] = restorer;
333 regs->gprs[15] = (unsigned long) frame;
334 /* Force default amode and default user address space control. */
335 regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA |
336 (PSW_USER_BITS & PSW_MASK_ASC) |
337 (regs->psw.mask & ~PSW_MASK_ASC);
338 regs->psw.addr = (unsigned long) ka->sa.sa_handler;
339
340 regs->gprs[2] = sig;
341 regs->gprs[3] = (unsigned long) &frame->sc;
342
343 /* We forgot to include these in the sigcontext.
344 To avoid breaking binary compatibility, they are passed as args. */
345 if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
346 sig == SIGTRAP || sig == SIGFPE) {
347 /* set extra registers only for synchronous signals */
348 regs->gprs[4] = regs->int_code & 127;
349 regs->gprs[5] = regs->int_parm_long;
350 regs->gprs[6] = current->thread.last_break;
351 }
352 return 0;
353}
354
355static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
356 struct pt_regs *regs)
357{
358 struct rt_sigframe __user *frame;
359 unsigned long uc_flags, restorer;
360 size_t frame_size;
361
362 frame_size = sizeof(struct rt_sigframe) - sizeof(_sigregs_ext);
363 uc_flags = 0;
364 if (cpu_has_vx()) {
365 frame_size += sizeof(_sigregs_ext);
366 uc_flags |= UC_VXRS;
367 }
368 frame = get_sigframe(ka: &ksig->ka, regs, frame_size);
369 if (frame == (void __user *) -1UL)
370 return -EFAULT;
371
372 /* Set up backchain. */
373 if (__put_user(regs->gprs[15], (addr_t __user *) frame))
374 return -EFAULT;
375
376 /* Set up to return from userspace. If provided, use a stub
377 already in userspace. */
378 if (ksig->ka.sa.sa_flags & SA_RESTORER)
379 restorer = (unsigned long) ksig->ka.sa.sa_restorer;
380 else
381 restorer = VDSO_SYMBOL(current, rt_sigreturn);
382
383 /* Create siginfo on the signal stack */
384 if (copy_siginfo_to_user(to: &frame->info, from: &ksig->info))
385 return -EFAULT;
386
387 /* Store registers needed to create the signal frame */
388 store_sigregs();
389
390 /* Create ucontext on the signal stack. */
391 if (__put_user(uc_flags, &frame->uc.uc_flags) ||
392 __put_user(NULL, &frame->uc.uc_link) ||
393 __save_altstack(&frame->uc.uc_stack, regs->gprs[15]) ||
394 save_sigregs(regs, &frame->uc.uc_mcontext) ||
395 __copy_to_user(to: &frame->uc.uc_sigmask, from: set, n: sizeof(*set)) ||
396 save_sigregs_ext(regs, &frame->uc.uc_mcontext_ext))
397 return -EFAULT;
398
399 /* Set up registers for signal handler */
400 regs->gprs[14] = restorer;
401 regs->gprs[15] = (unsigned long) frame;
402 /* Force default amode and default user address space control. */
403 regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA |
404 (PSW_USER_BITS & PSW_MASK_ASC) |
405 (regs->psw.mask & ~PSW_MASK_ASC);
406 regs->psw.addr = (unsigned long) ksig->ka.sa.sa_handler;
407
408 regs->gprs[2] = ksig->sig;
409 regs->gprs[3] = (unsigned long) &frame->info;
410 regs->gprs[4] = (unsigned long) &frame->uc;
411 regs->gprs[5] = current->thread.last_break;
412 return 0;
413}
414
415static void handle_signal(struct ksignal *ksig, sigset_t *oldset,
416 struct pt_regs *regs)
417{
418 int ret;
419
420 /* Set up the stack frame */
421 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
422 ret = setup_rt_frame(ksig, set: oldset, regs);
423 else
424 ret = setup_frame(sig: ksig->sig, ka: &ksig->ka, set: oldset, regs);
425
426 signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP));
427}
428
429/*
430 * Note that 'init' is a special process: it doesn't get signals it doesn't
431 * want to handle. Thus you cannot kill init even with a SIGKILL even by
432 * mistake.
433 *
434 * Note that we go through the signals twice: once to check the signals that
435 * the kernel can handle, and then we build all the user-level signal handling
436 * stack-frames in one go after that.
437 */
438
439void arch_do_signal_or_restart(struct pt_regs *regs)
440{
441 struct ksignal ksig;
442 sigset_t *oldset = sigmask_to_save();
443
444 /*
445 * Get signal to deliver. When running under ptrace, at this point
446 * the debugger may change all our registers, including the system
447 * call information.
448 */
449 current->thread.system_call =
450 test_pt_regs_flag(regs, PIF_SYSCALL) ? regs->int_code : 0;
451
452 if (get_signal(ksig: &ksig)) {
453 /* Whee! Actually deliver the signal. */
454 if (current->thread.system_call) {
455 regs->int_code = current->thread.system_call;
456 /* Check for system call restarting. */
457 switch (regs->gprs[2]) {
458 case -ERESTART_RESTARTBLOCK:
459 case -ERESTARTNOHAND:
460 regs->gprs[2] = -EINTR;
461 break;
462 case -ERESTARTSYS:
463 if (!(ksig.ka.sa.sa_flags & SA_RESTART)) {
464 regs->gprs[2] = -EINTR;
465 break;
466 }
467 fallthrough;
468 case -ERESTARTNOINTR:
469 regs->gprs[2] = regs->orig_gpr2;
470 regs->psw.addr =
471 __rewind_psw(regs->psw,
472 regs->int_code >> 16);
473 break;
474 }
475 }
476 /* No longer in a system call */
477 clear_pt_regs_flag(regs, PIF_SYSCALL);
478
479 rseq_signal_deliver(ksig: &ksig, regs);
480 handle_signal(ksig: &ksig, oldset, regs);
481 return;
482 }
483
484 /* No handlers present - check for system call restart */
485 clear_pt_regs_flag(regs, PIF_SYSCALL);
486 if (current->thread.system_call) {
487 regs->int_code = current->thread.system_call;
488 switch (regs->gprs[2]) {
489 case -ERESTART_RESTARTBLOCK:
490 /* Restart with sys_restart_syscall */
491 regs->gprs[2] = regs->orig_gpr2;
492 current->restart_block.arch_data = regs->psw.addr;
493 regs->psw.addr = VDSO_SYMBOL(current, restart_syscall);
494 if (test_thread_flag(TIF_SINGLE_STEP))
495 clear_thread_flag(TIF_PER_TRAP);
496 break;
497 case -ERESTARTNOHAND:
498 case -ERESTARTSYS:
499 case -ERESTARTNOINTR:
500 regs->gprs[2] = regs->orig_gpr2;
501 regs->psw.addr = __rewind_psw(regs->psw, regs->int_code >> 16);
502 if (test_thread_flag(TIF_SINGLE_STEP))
503 clear_thread_flag(TIF_PER_TRAP);
504 break;
505 }
506 }
507
508 /*
509 * If there's no signal to deliver, we just put the saved sigmask back.
510 */
511 restore_saved_sigmask();
512}
513

source code of linux/arch/s390/kernel/signal.c