xref: /openbmc/linux/arch/s390/kernel/compat_signal.c (revision 4f205687)
1 /*
2  *    Copyright IBM Corp. 2000, 2006
3  *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
4  *               Gerhard Tonn (ton@de.ibm.com)
5  *
6  *  Copyright (C) 1991, 1992  Linus Torvalds
7  *
8  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
9  */
10 
11 #include <linux/compat.h>
12 #include <linux/sched.h>
13 #include <linux/mm.h>
14 #include <linux/smp.h>
15 #include <linux/kernel.h>
16 #include <linux/signal.h>
17 #include <linux/errno.h>
18 #include <linux/wait.h>
19 #include <linux/ptrace.h>
20 #include <linux/unistd.h>
21 #include <linux/stddef.h>
22 #include <linux/tty.h>
23 #include <linux/personality.h>
24 #include <linux/binfmts.h>
25 #include <asm/ucontext.h>
26 #include <asm/uaccess.h>
27 #include <asm/lowcore.h>
28 #include <asm/switch_to.h>
29 #include "compat_linux.h"
30 #include "compat_ptrace.h"
31 #include "entry.h"
32 
33 typedef struct
34 {
35 	__u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
36 	struct sigcontext32 sc;
37 	_sigregs32 sregs;
38 	int signo;
39 	_sigregs_ext32 sregs_ext;
40 	__u16 svc_insn;		/* Offset of svc_insn is NOT fixed! */
41 } sigframe32;
42 
43 typedef struct
44 {
45 	__u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
46 	__u16 svc_insn;
47 	compat_siginfo_t info;
48 	struct ucontext32 uc;
49 } rt_sigframe32;
50 
51 static inline void sigset_to_sigset32(unsigned long *set64,
52 				      compat_sigset_word *set32)
53 {
54 	set32[0] = (compat_sigset_word) set64[0];
55 	set32[1] = (compat_sigset_word)(set64[0] >> 32);
56 }
57 
58 static inline void sigset32_to_sigset(compat_sigset_word *set32,
59 				      unsigned long *set64)
60 {
61 	set64[0] = (unsigned long) set32[0] | ((unsigned long) set32[1] << 32);
62 }
63 
64 int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from)
65 {
66 	int err;
67 
68 	/* If you change siginfo_t structure, please be sure
69 	   this code is fixed accordingly.
70 	   It should never copy any pad contained in the structure
71 	   to avoid security leaks, but must copy the generic
72 	   3 ints plus the relevant union member.
73 	   This routine must convert siginfo from 64bit to 32bit as well
74 	   at the same time.  */
75 	err = __put_user(from->si_signo, &to->si_signo);
76 	err |= __put_user(from->si_errno, &to->si_errno);
77 	err |= __put_user((short)from->si_code, &to->si_code);
78 	if (from->si_code < 0)
79 		err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
80 	else {
81 		switch (from->si_code >> 16) {
82 		case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
83 		case __SI_MESGQ >> 16:
84 			err |= __put_user(from->si_int, &to->si_int);
85 			/* fallthrough */
86 		case __SI_KILL >> 16:
87 			err |= __put_user(from->si_pid, &to->si_pid);
88 			err |= __put_user(from->si_uid, &to->si_uid);
89 			break;
90 		case __SI_CHLD >> 16:
91 			err |= __put_user(from->si_pid, &to->si_pid);
92 			err |= __put_user(from->si_uid, &to->si_uid);
93 			err |= __put_user(from->si_utime, &to->si_utime);
94 			err |= __put_user(from->si_stime, &to->si_stime);
95 			err |= __put_user(from->si_status, &to->si_status);
96 			break;
97 		case __SI_FAULT >> 16:
98 			err |= __put_user((unsigned long) from->si_addr,
99 					  &to->si_addr);
100 			break;
101 		case __SI_POLL >> 16:
102 			err |= __put_user(from->si_band, &to->si_band);
103 			err |= __put_user(from->si_fd, &to->si_fd);
104 			break;
105 		case __SI_TIMER >> 16:
106 			err |= __put_user(from->si_tid, &to->si_tid);
107 			err |= __put_user(from->si_overrun, &to->si_overrun);
108 			err |= __put_user(from->si_int, &to->si_int);
109 			break;
110 		default:
111 			break;
112 		}
113 	}
114 	return err ? -EFAULT : 0;
115 }
116 
117 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
118 {
119 	int err;
120 	u32 tmp;
121 
122 	err = __get_user(to->si_signo, &from->si_signo);
123 	err |= __get_user(to->si_errno, &from->si_errno);
124 	err |= __get_user(to->si_code, &from->si_code);
125 
126 	if (to->si_code < 0)
127 		err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
128 	else {
129 		switch (to->si_code >> 16) {
130 		case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
131 		case __SI_MESGQ >> 16:
132 			err |= __get_user(to->si_int, &from->si_int);
133 			/* fallthrough */
134 		case __SI_KILL >> 16:
135 			err |= __get_user(to->si_pid, &from->si_pid);
136 			err |= __get_user(to->si_uid, &from->si_uid);
137 			break;
138 		case __SI_CHLD >> 16:
139 			err |= __get_user(to->si_pid, &from->si_pid);
140 			err |= __get_user(to->si_uid, &from->si_uid);
141 			err |= __get_user(to->si_utime, &from->si_utime);
142 			err |= __get_user(to->si_stime, &from->si_stime);
143 			err |= __get_user(to->si_status, &from->si_status);
144 			break;
145 		case __SI_FAULT >> 16:
146 			err |= __get_user(tmp, &from->si_addr);
147 			to->si_addr = (void __force __user *)
148 				(u64) (tmp & PSW32_ADDR_INSN);
149 			break;
150 		case __SI_POLL >> 16:
151 			err |= __get_user(to->si_band, &from->si_band);
152 			err |= __get_user(to->si_fd, &from->si_fd);
153 			break;
154 		case __SI_TIMER >> 16:
155 			err |= __get_user(to->si_tid, &from->si_tid);
156 			err |= __get_user(to->si_overrun, &from->si_overrun);
157 			err |= __get_user(to->si_int, &from->si_int);
158 			break;
159 		default:
160 			break;
161 		}
162 	}
163 	return err ? -EFAULT : 0;
164 }
165 
166 /* Store registers needed to create the signal frame */
167 static void store_sigregs(void)
168 {
169 	save_access_regs(current->thread.acrs);
170 	save_fpu_regs();
171 }
172 
173 /* Load registers after signal return */
174 static void load_sigregs(void)
175 {
176 	restore_access_regs(current->thread.acrs);
177 }
178 
179 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
180 {
181 	_sigregs32 user_sregs;
182 	int i;
183 
184 	user_sregs.regs.psw.mask = (__u32)(regs->psw.mask >> 32);
185 	user_sregs.regs.psw.mask &= PSW32_MASK_USER | PSW32_MASK_RI;
186 	user_sregs.regs.psw.mask |= PSW32_USER_BITS;
187 	user_sregs.regs.psw.addr = (__u32) regs->psw.addr |
188 		(__u32)(regs->psw.mask & PSW_MASK_BA);
189 	for (i = 0; i < NUM_GPRS; i++)
190 		user_sregs.regs.gprs[i] = (__u32) regs->gprs[i];
191 	memcpy(&user_sregs.regs.acrs, current->thread.acrs,
192 	       sizeof(user_sregs.regs.acrs));
193 	fpregs_store((_s390_fp_regs *) &user_sregs.fpregs, &current->thread.fpu);
194 	if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs32)))
195 		return -EFAULT;
196 	return 0;
197 }
198 
199 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
200 {
201 	_sigregs32 user_sregs;
202 	int i;
203 
204 	/* Alwys make any pending restarted system call return -EINTR */
205 	current->restart_block.fn = do_no_restart_syscall;
206 
207 	if (__copy_from_user(&user_sregs, &sregs->regs, sizeof(user_sregs)))
208 		return -EFAULT;
209 
210 	if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW32_MASK_RI))
211 		return -EINVAL;
212 
213 	/* Test the floating-point-control word. */
214 	if (test_fp_ctl(user_sregs.fpregs.fpc))
215 		return -EINVAL;
216 
217 	/* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */
218 	regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | PSW_MASK_RI)) |
219 		(__u64)(user_sregs.regs.psw.mask & PSW32_MASK_USER) << 32 |
220 		(__u64)(user_sregs.regs.psw.mask & PSW32_MASK_RI) << 32 |
221 		(__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_AMODE);
222 	/* Check for invalid user address space control. */
223 	if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME)
224 		regs->psw.mask = PSW_ASC_PRIMARY |
225 			(regs->psw.mask & ~PSW_MASK_ASC);
226 	regs->psw.addr = (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_INSN);
227 	for (i = 0; i < NUM_GPRS; i++)
228 		regs->gprs[i] = (__u64) user_sregs.regs.gprs[i];
229 	memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
230 	       sizeof(current->thread.acrs));
231 	fpregs_load((_s390_fp_regs *) &user_sregs.fpregs, &current->thread.fpu);
232 
233 	clear_pt_regs_flag(regs, PIF_SYSCALL); /* No longer in a system call */
234 	return 0;
235 }
236 
237 static int save_sigregs_ext32(struct pt_regs *regs,
238 			      _sigregs_ext32 __user *sregs_ext)
239 {
240 	__u32 gprs_high[NUM_GPRS];
241 	__u64 vxrs[__NUM_VXRS_LOW];
242 	int i;
243 
244 	/* Save high gprs to signal stack */
245 	for (i = 0; i < NUM_GPRS; i++)
246 		gprs_high[i] = regs->gprs[i] >> 32;
247 	if (__copy_to_user(&sregs_ext->gprs_high, &gprs_high,
248 			   sizeof(sregs_ext->gprs_high)))
249 		return -EFAULT;
250 
251 	/* Save vector registers to signal stack */
252 	if (MACHINE_HAS_VX) {
253 		for (i = 0; i < __NUM_VXRS_LOW; i++)
254 			vxrs[i] = *((__u64 *)(current->thread.fpu.vxrs + i) + 1);
255 		if (__copy_to_user(&sregs_ext->vxrs_low, vxrs,
256 				   sizeof(sregs_ext->vxrs_low)) ||
257 		    __copy_to_user(&sregs_ext->vxrs_high,
258 				   current->thread.fpu.vxrs + __NUM_VXRS_LOW,
259 				   sizeof(sregs_ext->vxrs_high)))
260 			return -EFAULT;
261 	}
262 	return 0;
263 }
264 
265 static int restore_sigregs_ext32(struct pt_regs *regs,
266 				 _sigregs_ext32 __user *sregs_ext)
267 {
268 	__u32 gprs_high[NUM_GPRS];
269 	__u64 vxrs[__NUM_VXRS_LOW];
270 	int i;
271 
272 	/* Restore high gprs from signal stack */
273 	if (__copy_from_user(&gprs_high, &sregs_ext->gprs_high,
274 			     sizeof(sregs_ext->gprs_high)))
275 		return -EFAULT;
276 	for (i = 0; i < NUM_GPRS; i++)
277 		*(__u32 *)&regs->gprs[i] = gprs_high[i];
278 
279 	/* Restore vector registers from signal stack */
280 	if (MACHINE_HAS_VX) {
281 		if (__copy_from_user(vxrs, &sregs_ext->vxrs_low,
282 				     sizeof(sregs_ext->vxrs_low)) ||
283 		    __copy_from_user(current->thread.fpu.vxrs + __NUM_VXRS_LOW,
284 				     &sregs_ext->vxrs_high,
285 				     sizeof(sregs_ext->vxrs_high)))
286 			return -EFAULT;
287 		for (i = 0; i < __NUM_VXRS_LOW; i++)
288 			*((__u64 *)(current->thread.fpu.vxrs + i) + 1) = vxrs[i];
289 	}
290 	return 0;
291 }
292 
293 COMPAT_SYSCALL_DEFINE0(sigreturn)
294 {
295 	struct pt_regs *regs = task_pt_regs(current);
296 	sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
297 	compat_sigset_t cset;
298 	sigset_t set;
299 
300 	if (__copy_from_user(&cset.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
301 		goto badframe;
302 	sigset32_to_sigset(cset.sig, set.sig);
303 	set_current_blocked(&set);
304 	save_fpu_regs();
305 	if (restore_sigregs32(regs, &frame->sregs))
306 		goto badframe;
307 	if (restore_sigregs_ext32(regs, &frame->sregs_ext))
308 		goto badframe;
309 	load_sigregs();
310 	return regs->gprs[2];
311 badframe:
312 	force_sig(SIGSEGV, current);
313 	return 0;
314 }
315 
316 COMPAT_SYSCALL_DEFINE0(rt_sigreturn)
317 {
318 	struct pt_regs *regs = task_pt_regs(current);
319 	rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
320 	compat_sigset_t cset;
321 	sigset_t set;
322 
323 	if (__copy_from_user(&cset, &frame->uc.uc_sigmask, sizeof(cset)))
324 		goto badframe;
325 	sigset32_to_sigset(cset.sig, set.sig);
326 	set_current_blocked(&set);
327 	if (compat_restore_altstack(&frame->uc.uc_stack))
328 		goto badframe;
329 	save_fpu_regs();
330 	if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
331 		goto badframe;
332 	if (restore_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext))
333 		goto badframe;
334 	load_sigregs();
335 	return regs->gprs[2];
336 badframe:
337 	force_sig(SIGSEGV, current);
338 	return 0;
339 }
340 
341 /*
342  * Set up a signal frame.
343  */
344 
345 
346 /*
347  * Determine which stack to use..
348  */
349 static inline void __user *
350 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
351 {
352 	unsigned long sp;
353 
354 	/* Default to using normal stack */
355 	sp = (unsigned long) A(regs->gprs[15]);
356 
357 	/* Overflow on alternate signal stack gives SIGSEGV. */
358 	if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
359 		return (void __user *) -1UL;
360 
361 	/* This is the X/Open sanctioned signal stack switching.  */
362 	if (ka->sa.sa_flags & SA_ONSTACK) {
363 		if (! sas_ss_flags(sp))
364 			sp = current->sas_ss_sp + current->sas_ss_size;
365 	}
366 
367 	return (void __user *)((sp - frame_size) & -8ul);
368 }
369 
370 static int setup_frame32(struct ksignal *ksig, sigset_t *set,
371 			 struct pt_regs *regs)
372 {
373 	int sig = ksig->sig;
374 	sigframe32 __user *frame;
375 	struct sigcontext32 sc;
376 	unsigned long restorer;
377 	size_t frame_size;
378 
379 	/*
380 	 * gprs_high are always present for 31-bit compat tasks.
381 	 * The space for vector registers is only allocated if
382 	 * the machine supports it
383 	 */
384 	frame_size = sizeof(*frame) - sizeof(frame->sregs_ext.__reserved);
385 	if (!MACHINE_HAS_VX)
386 		frame_size -= sizeof(frame->sregs_ext.vxrs_low) +
387 			      sizeof(frame->sregs_ext.vxrs_high);
388 	frame = get_sigframe(&ksig->ka, regs, frame_size);
389 	if (frame == (void __user *) -1UL)
390 		return -EFAULT;
391 
392 	/* Set up backchain. */
393 	if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
394 		return -EFAULT;
395 
396 	/* Create struct sigcontext32 on the signal stack */
397 	sigset_to_sigset32(set->sig, sc.oldmask);
398 	sc.sregs = (__u32)(unsigned long __force) &frame->sregs;
399 	if (__copy_to_user(&frame->sc, &sc, sizeof(frame->sc)))
400 		return -EFAULT;
401 
402 	/* Store registers needed to create the signal frame */
403 	store_sigregs();
404 
405 	/* Create _sigregs32 on the signal stack */
406 	if (save_sigregs32(regs, &frame->sregs))
407 		return -EFAULT;
408 
409 	/* Place signal number on stack to allow backtrace from handler.  */
410 	if (__put_user(regs->gprs[2], (int __force __user *) &frame->signo))
411 		return -EFAULT;
412 
413 	/* Create _sigregs_ext32 on the signal stack */
414 	if (save_sigregs_ext32(regs, &frame->sregs_ext))
415 		return -EFAULT;
416 
417 	/* Set up to return from userspace.  If provided, use a stub
418 	   already in userspace.  */
419 	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
420 		restorer = (unsigned long __force)
421 			ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE;
422 	} else {
423 		/* Signal frames without vectors registers are short ! */
424 		__u16 __user *svc = (void __user *) frame + frame_size - 2;
425 		if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, svc))
426 			return -EFAULT;
427 		restorer = (unsigned long __force) svc | PSW32_ADDR_AMODE;
428         }
429 
430 	/* Set up registers for signal handler */
431 	regs->gprs[14] = restorer;
432 	regs->gprs[15] = (__force __u64) frame;
433 	/* Force 31 bit amode and default user address space control. */
434 	regs->psw.mask = PSW_MASK_BA |
435 		(PSW_USER_BITS & PSW_MASK_ASC) |
436 		(regs->psw.mask & ~PSW_MASK_ASC);
437 	regs->psw.addr = (__force __u64) ksig->ka.sa.sa_handler;
438 
439 	regs->gprs[2] = sig;
440 	regs->gprs[3] = (__force __u64) &frame->sc;
441 
442 	/* We forgot to include these in the sigcontext.
443 	   To avoid breaking binary compatibility, they are passed as args. */
444 	if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
445 	    sig == SIGTRAP || sig == SIGFPE) {
446 		/* set extra registers only for synchronous signals */
447 		regs->gprs[4] = regs->int_code & 127;
448 		regs->gprs[5] = regs->int_parm_long;
449 		regs->gprs[6] = task_thread_info(current)->last_break;
450 	}
451 
452 	return 0;
453 }
454 
455 static int setup_rt_frame32(struct ksignal *ksig, sigset_t *set,
456 			    struct pt_regs *regs)
457 {
458 	compat_sigset_t cset;
459 	rt_sigframe32 __user *frame;
460 	unsigned long restorer;
461 	size_t frame_size;
462 	u32 uc_flags;
463 
464 	frame_size = sizeof(*frame) -
465 		     sizeof(frame->uc.uc_mcontext_ext.__reserved);
466 	/*
467 	 * gprs_high are always present for 31-bit compat tasks.
468 	 * The space for vector registers is only allocated if
469 	 * the machine supports it
470 	 */
471 	uc_flags = UC_GPRS_HIGH;
472 	if (MACHINE_HAS_VX) {
473 		uc_flags |= UC_VXRS;
474 	} else
475 		frame_size -= sizeof(frame->uc.uc_mcontext_ext.vxrs_low) +
476 			      sizeof(frame->uc.uc_mcontext_ext.vxrs_high);
477 	frame = get_sigframe(&ksig->ka, regs, frame_size);
478 	if (frame == (void __user *) -1UL)
479 		return -EFAULT;
480 
481 	/* Set up backchain. */
482 	if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame))
483 		return -EFAULT;
484 
485 	/* Set up to return from userspace.  If provided, use a stub
486 	   already in userspace.  */
487 	if (ksig->ka.sa.sa_flags & SA_RESTORER) {
488 		restorer = (unsigned long __force)
489 			ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE;
490 	} else {
491 		__u16 __user *svc = &frame->svc_insn;
492 		if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, svc))
493 			return -EFAULT;
494 		restorer = (unsigned long __force) svc | PSW32_ADDR_AMODE;
495 	}
496 
497 	/* Create siginfo on the signal stack */
498 	if (copy_siginfo_to_user32(&frame->info, &ksig->info))
499 		return -EFAULT;
500 
501 	/* Store registers needed to create the signal frame */
502 	store_sigregs();
503 
504 	/* Create ucontext on the signal stack. */
505 	sigset_to_sigset32(set->sig, cset.sig);
506 	if (__put_user(uc_flags, &frame->uc.uc_flags) ||
507 	    __put_user(0, &frame->uc.uc_link) ||
508 	    __compat_save_altstack(&frame->uc.uc_stack, regs->gprs[15]) ||
509 	    save_sigregs32(regs, &frame->uc.uc_mcontext) ||
510 	    __copy_to_user(&frame->uc.uc_sigmask, &cset, sizeof(cset)) ||
511 	    save_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext))
512 		return -EFAULT;
513 
514 	/* Set up registers for signal handler */
515 	regs->gprs[14] = restorer;
516 	regs->gprs[15] = (__force __u64) frame;
517 	/* Force 31 bit amode and default user address space control. */
518 	regs->psw.mask = PSW_MASK_BA |
519 		(PSW_USER_BITS & PSW_MASK_ASC) |
520 		(regs->psw.mask & ~PSW_MASK_ASC);
521 	regs->psw.addr = (__u64 __force) ksig->ka.sa.sa_handler;
522 
523 	regs->gprs[2] = ksig->sig;
524 	regs->gprs[3] = (__force __u64) &frame->info;
525 	regs->gprs[4] = (__force __u64) &frame->uc;
526 	regs->gprs[5] = task_thread_info(current)->last_break;
527 	return 0;
528 }
529 
530 /*
531  * OK, we're invoking a handler
532  */
533 
534 void handle_signal32(struct ksignal *ksig, sigset_t *oldset,
535 		     struct pt_regs *regs)
536 {
537 	int ret;
538 
539 	/* Set up the stack frame */
540 	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
541 		ret = setup_rt_frame32(ksig, oldset, regs);
542 	else
543 		ret = setup_frame32(ksig, oldset, regs);
544 
545 	signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP));
546 }
547 
548