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