xref: /openbmc/linux/arch/arm64/kernel/signal32.c (revision 98ddec80)
1 /*
2  * Based on arch/arm/kernel/signal.c
3  *
4  * Copyright (C) 1995-2009 Russell King
5  * Copyright (C) 2012 ARM Ltd.
6  * Modified by Will Deacon <will.deacon@arm.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
19  */
20 
21 #include <linux/compat.h>
22 #include <linux/signal.h>
23 #include <linux/syscalls.h>
24 #include <linux/ratelimit.h>
25 
26 #include <asm/esr.h>
27 #include <asm/fpsimd.h>
28 #include <asm/signal32.h>
29 #include <asm/traps.h>
30 #include <linux/uaccess.h>
31 #include <asm/unistd.h>
32 
33 struct compat_sigcontext {
34 	/* We always set these two fields to 0 */
35 	compat_ulong_t			trap_no;
36 	compat_ulong_t			error_code;
37 
38 	compat_ulong_t			oldmask;
39 	compat_ulong_t			arm_r0;
40 	compat_ulong_t			arm_r1;
41 	compat_ulong_t			arm_r2;
42 	compat_ulong_t			arm_r3;
43 	compat_ulong_t			arm_r4;
44 	compat_ulong_t			arm_r5;
45 	compat_ulong_t			arm_r6;
46 	compat_ulong_t			arm_r7;
47 	compat_ulong_t			arm_r8;
48 	compat_ulong_t			arm_r9;
49 	compat_ulong_t			arm_r10;
50 	compat_ulong_t			arm_fp;
51 	compat_ulong_t			arm_ip;
52 	compat_ulong_t			arm_sp;
53 	compat_ulong_t			arm_lr;
54 	compat_ulong_t			arm_pc;
55 	compat_ulong_t			arm_cpsr;
56 	compat_ulong_t			fault_address;
57 };
58 
59 struct compat_ucontext {
60 	compat_ulong_t			uc_flags;
61 	compat_uptr_t			uc_link;
62 	compat_stack_t			uc_stack;
63 	struct compat_sigcontext	uc_mcontext;
64 	compat_sigset_t			uc_sigmask;
65 	int		__unused[32 - (sizeof (compat_sigset_t) / sizeof (int))];
66 	compat_ulong_t	uc_regspace[128] __attribute__((__aligned__(8)));
67 };
68 
69 struct compat_vfp_sigframe {
70 	compat_ulong_t	magic;
71 	compat_ulong_t	size;
72 	struct compat_user_vfp {
73 		compat_u64	fpregs[32];
74 		compat_ulong_t	fpscr;
75 	} ufp;
76 	struct compat_user_vfp_exc {
77 		compat_ulong_t	fpexc;
78 		compat_ulong_t	fpinst;
79 		compat_ulong_t	fpinst2;
80 	} ufp_exc;
81 } __attribute__((__aligned__(8)));
82 
83 #define VFP_MAGIC		0x56465001
84 #define VFP_STORAGE_SIZE	sizeof(struct compat_vfp_sigframe)
85 
86 #define FSR_WRITE_SHIFT		(11)
87 
88 struct compat_aux_sigframe {
89 	struct compat_vfp_sigframe	vfp;
90 
91 	/* Something that isn't a valid magic number for any coprocessor.  */
92 	unsigned long			end_magic;
93 } __attribute__((__aligned__(8)));
94 
95 struct compat_sigframe {
96 	struct compat_ucontext	uc;
97 	compat_ulong_t		retcode[2];
98 };
99 
100 struct compat_rt_sigframe {
101 	struct compat_siginfo info;
102 	struct compat_sigframe sig;
103 };
104 
105 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
106 
107 static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
108 {
109 	compat_sigset_t	cset;
110 
111 	cset.sig[0] = set->sig[0] & 0xffffffffull;
112 	cset.sig[1] = set->sig[0] >> 32;
113 
114 	return copy_to_user(uset, &cset, sizeof(*uset));
115 }
116 
117 static inline int get_sigset_t(sigset_t *set,
118 			       const compat_sigset_t __user *uset)
119 {
120 	compat_sigset_t s32;
121 
122 	if (copy_from_user(&s32, uset, sizeof(*uset)))
123 		return -EFAULT;
124 
125 	set->sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
126 	return 0;
127 }
128 
129 /*
130  * VFP save/restore code.
131  *
132  * We have to be careful with endianness, since the fpsimd context-switch
133  * code operates on 128-bit (Q) register values whereas the compat ABI
134  * uses an array of 64-bit (D) registers. Consequently, we need to swap
135  * the two halves of each Q register when running on a big-endian CPU.
136  */
137 union __fpsimd_vreg {
138 	__uint128_t	raw;
139 	struct {
140 #ifdef __AARCH64EB__
141 		u64	hi;
142 		u64	lo;
143 #else
144 		u64	lo;
145 		u64	hi;
146 #endif
147 	};
148 };
149 
150 static int compat_preserve_vfp_context(struct compat_vfp_sigframe __user *frame)
151 {
152 	struct user_fpsimd_state const *fpsimd =
153 		&current->thread.uw.fpsimd_state;
154 	compat_ulong_t magic = VFP_MAGIC;
155 	compat_ulong_t size = VFP_STORAGE_SIZE;
156 	compat_ulong_t fpscr, fpexc;
157 	int i, err = 0;
158 
159 	/*
160 	 * Save the hardware registers to the fpsimd_state structure.
161 	 * Note that this also saves V16-31, which aren't visible
162 	 * in AArch32.
163 	 */
164 	fpsimd_signal_preserve_current_state();
165 
166 	/* Place structure header on the stack */
167 	__put_user_error(magic, &frame->magic, err);
168 	__put_user_error(size, &frame->size, err);
169 
170 	/*
171 	 * Now copy the FP registers. Since the registers are packed,
172 	 * we can copy the prefix we want (V0-V15) as it is.
173 	 */
174 	for (i = 0; i < ARRAY_SIZE(frame->ufp.fpregs); i += 2) {
175 		union __fpsimd_vreg vreg = {
176 			.raw = fpsimd->vregs[i >> 1],
177 		};
178 
179 		__put_user_error(vreg.lo, &frame->ufp.fpregs[i], err);
180 		__put_user_error(vreg.hi, &frame->ufp.fpregs[i + 1], err);
181 	}
182 
183 	/* Create an AArch32 fpscr from the fpsr and the fpcr. */
184 	fpscr = (fpsimd->fpsr & VFP_FPSCR_STAT_MASK) |
185 		(fpsimd->fpcr & VFP_FPSCR_CTRL_MASK);
186 	__put_user_error(fpscr, &frame->ufp.fpscr, err);
187 
188 	/*
189 	 * The exception register aren't available so we fake up a
190 	 * basic FPEXC and zero everything else.
191 	 */
192 	fpexc = (1 << 30);
193 	__put_user_error(fpexc, &frame->ufp_exc.fpexc, err);
194 	__put_user_error(0, &frame->ufp_exc.fpinst, err);
195 	__put_user_error(0, &frame->ufp_exc.fpinst2, err);
196 
197 	return err ? -EFAULT : 0;
198 }
199 
200 static int compat_restore_vfp_context(struct compat_vfp_sigframe __user *frame)
201 {
202 	struct user_fpsimd_state fpsimd;
203 	compat_ulong_t magic = VFP_MAGIC;
204 	compat_ulong_t size = VFP_STORAGE_SIZE;
205 	compat_ulong_t fpscr;
206 	int i, err = 0;
207 
208 	__get_user_error(magic, &frame->magic, err);
209 	__get_user_error(size, &frame->size, err);
210 
211 	if (err)
212 		return -EFAULT;
213 	if (magic != VFP_MAGIC || size != VFP_STORAGE_SIZE)
214 		return -EINVAL;
215 
216 	/* Copy the FP registers into the start of the fpsimd_state. */
217 	for (i = 0; i < ARRAY_SIZE(frame->ufp.fpregs); i += 2) {
218 		union __fpsimd_vreg vreg;
219 
220 		__get_user_error(vreg.lo, &frame->ufp.fpregs[i], err);
221 		__get_user_error(vreg.hi, &frame->ufp.fpregs[i + 1], err);
222 		fpsimd.vregs[i >> 1] = vreg.raw;
223 	}
224 
225 	/* Extract the fpsr and the fpcr from the fpscr */
226 	__get_user_error(fpscr, &frame->ufp.fpscr, err);
227 	fpsimd.fpsr = fpscr & VFP_FPSCR_STAT_MASK;
228 	fpsimd.fpcr = fpscr & VFP_FPSCR_CTRL_MASK;
229 
230 	/*
231 	 * We don't need to touch the exception register, so
232 	 * reload the hardware state.
233 	 */
234 	if (!err)
235 		fpsimd_update_current_state(&fpsimd);
236 
237 	return err ? -EFAULT : 0;
238 }
239 
240 static int compat_restore_sigframe(struct pt_regs *regs,
241 				   struct compat_sigframe __user *sf)
242 {
243 	int err;
244 	sigset_t set;
245 	struct compat_aux_sigframe __user *aux;
246 
247 	err = get_sigset_t(&set, &sf->uc.uc_sigmask);
248 	if (err == 0) {
249 		sigdelsetmask(&set, ~_BLOCKABLE);
250 		set_current_blocked(&set);
251 	}
252 
253 	__get_user_error(regs->regs[0], &sf->uc.uc_mcontext.arm_r0, err);
254 	__get_user_error(regs->regs[1], &sf->uc.uc_mcontext.arm_r1, err);
255 	__get_user_error(regs->regs[2], &sf->uc.uc_mcontext.arm_r2, err);
256 	__get_user_error(regs->regs[3], &sf->uc.uc_mcontext.arm_r3, err);
257 	__get_user_error(regs->regs[4], &sf->uc.uc_mcontext.arm_r4, err);
258 	__get_user_error(regs->regs[5], &sf->uc.uc_mcontext.arm_r5, err);
259 	__get_user_error(regs->regs[6], &sf->uc.uc_mcontext.arm_r6, err);
260 	__get_user_error(regs->regs[7], &sf->uc.uc_mcontext.arm_r7, err);
261 	__get_user_error(regs->regs[8], &sf->uc.uc_mcontext.arm_r8, err);
262 	__get_user_error(regs->regs[9], &sf->uc.uc_mcontext.arm_r9, err);
263 	__get_user_error(regs->regs[10], &sf->uc.uc_mcontext.arm_r10, err);
264 	__get_user_error(regs->regs[11], &sf->uc.uc_mcontext.arm_fp, err);
265 	__get_user_error(regs->regs[12], &sf->uc.uc_mcontext.arm_ip, err);
266 	__get_user_error(regs->compat_sp, &sf->uc.uc_mcontext.arm_sp, err);
267 	__get_user_error(regs->compat_lr, &sf->uc.uc_mcontext.arm_lr, err);
268 	__get_user_error(regs->pc, &sf->uc.uc_mcontext.arm_pc, err);
269 	__get_user_error(regs->pstate, &sf->uc.uc_mcontext.arm_cpsr, err);
270 
271 	/*
272 	 * Avoid compat_sys_sigreturn() restarting.
273 	 */
274 	forget_syscall(regs);
275 
276 	err |= !valid_user_regs(&regs->user_regs, current);
277 
278 	aux = (struct compat_aux_sigframe __user *) sf->uc.uc_regspace;
279 	if (err == 0)
280 		err |= compat_restore_vfp_context(&aux->vfp);
281 
282 	return err;
283 }
284 
285 asmlinkage int compat_sys_sigreturn(struct pt_regs *regs)
286 {
287 	struct compat_sigframe __user *frame;
288 
289 	/* Always make any pending restarted system calls return -EINTR */
290 	current->restart_block.fn = do_no_restart_syscall;
291 
292 	/*
293 	 * Since we stacked the signal on a 64-bit boundary,
294 	 * then 'sp' should be word aligned here.  If it's
295 	 * not, then the user is trying to mess with us.
296 	 */
297 	if (regs->compat_sp & 7)
298 		goto badframe;
299 
300 	frame = (struct compat_sigframe __user *)regs->compat_sp;
301 
302 	if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
303 		goto badframe;
304 
305 	if (compat_restore_sigframe(regs, frame))
306 		goto badframe;
307 
308 	return regs->regs[0];
309 
310 badframe:
311 	arm64_notify_segfault(regs->compat_sp);
312 	return 0;
313 }
314 
315 asmlinkage int compat_sys_rt_sigreturn(struct pt_regs *regs)
316 {
317 	struct compat_rt_sigframe __user *frame;
318 
319 	/* Always make any pending restarted system calls return -EINTR */
320 	current->restart_block.fn = do_no_restart_syscall;
321 
322 	/*
323 	 * Since we stacked the signal on a 64-bit boundary,
324 	 * then 'sp' should be word aligned here.  If it's
325 	 * not, then the user is trying to mess with us.
326 	 */
327 	if (regs->compat_sp & 7)
328 		goto badframe;
329 
330 	frame = (struct compat_rt_sigframe __user *)regs->compat_sp;
331 
332 	if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
333 		goto badframe;
334 
335 	if (compat_restore_sigframe(regs, &frame->sig))
336 		goto badframe;
337 
338 	if (compat_restore_altstack(&frame->sig.uc.uc_stack))
339 		goto badframe;
340 
341 	return regs->regs[0];
342 
343 badframe:
344 	arm64_notify_segfault(regs->compat_sp);
345 	return 0;
346 }
347 
348 static void __user *compat_get_sigframe(struct ksignal *ksig,
349 					struct pt_regs *regs,
350 					int framesize)
351 {
352 	compat_ulong_t sp = sigsp(regs->compat_sp, ksig);
353 	void __user *frame;
354 
355 	/*
356 	 * ATPCS B01 mandates 8-byte alignment
357 	 */
358 	frame = compat_ptr((compat_uptr_t)((sp - framesize) & ~7));
359 
360 	/*
361 	 * Check that we can actually write to the signal frame.
362 	 */
363 	if (!access_ok(VERIFY_WRITE, frame, framesize))
364 		frame = NULL;
365 
366 	return frame;
367 }
368 
369 static void compat_setup_return(struct pt_regs *regs, struct k_sigaction *ka,
370 				compat_ulong_t __user *rc, void __user *frame,
371 				int usig)
372 {
373 	compat_ulong_t handler = ptr_to_compat(ka->sa.sa_handler);
374 	compat_ulong_t retcode;
375 	compat_ulong_t spsr = regs->pstate & ~(PSR_f | COMPAT_PSR_E_BIT);
376 	int thumb;
377 
378 	/* Check if the handler is written for ARM or Thumb */
379 	thumb = handler & 1;
380 
381 	if (thumb)
382 		spsr |= COMPAT_PSR_T_BIT;
383 	else
384 		spsr &= ~COMPAT_PSR_T_BIT;
385 
386 	/* The IT state must be cleared for both ARM and Thumb-2 */
387 	spsr &= ~COMPAT_PSR_IT_MASK;
388 
389 	/* Restore the original endianness */
390 	spsr |= COMPAT_PSR_ENDSTATE;
391 
392 	if (ka->sa.sa_flags & SA_RESTORER) {
393 		retcode = ptr_to_compat(ka->sa.sa_restorer);
394 	} else {
395 		/* Set up sigreturn pointer */
396 		unsigned int idx = thumb << 1;
397 
398 		if (ka->sa.sa_flags & SA_SIGINFO)
399 			idx += 3;
400 
401 		retcode = AARCH32_VECTORS_BASE +
402 			  AARCH32_KERN_SIGRET_CODE_OFFSET +
403 			  (idx << 2) + thumb;
404 	}
405 
406 	regs->regs[0]	= usig;
407 	regs->compat_sp	= ptr_to_compat(frame);
408 	regs->compat_lr	= retcode;
409 	regs->pc	= handler;
410 	regs->pstate	= spsr;
411 }
412 
413 static int compat_setup_sigframe(struct compat_sigframe __user *sf,
414 				 struct pt_regs *regs, sigset_t *set)
415 {
416 	struct compat_aux_sigframe __user *aux;
417 	int err = 0;
418 
419 	__put_user_error(regs->regs[0], &sf->uc.uc_mcontext.arm_r0, err);
420 	__put_user_error(regs->regs[1], &sf->uc.uc_mcontext.arm_r1, err);
421 	__put_user_error(regs->regs[2], &sf->uc.uc_mcontext.arm_r2, err);
422 	__put_user_error(regs->regs[3], &sf->uc.uc_mcontext.arm_r3, err);
423 	__put_user_error(regs->regs[4], &sf->uc.uc_mcontext.arm_r4, err);
424 	__put_user_error(regs->regs[5], &sf->uc.uc_mcontext.arm_r5, err);
425 	__put_user_error(regs->regs[6], &sf->uc.uc_mcontext.arm_r6, err);
426 	__put_user_error(regs->regs[7], &sf->uc.uc_mcontext.arm_r7, err);
427 	__put_user_error(regs->regs[8], &sf->uc.uc_mcontext.arm_r8, err);
428 	__put_user_error(regs->regs[9], &sf->uc.uc_mcontext.arm_r9, err);
429 	__put_user_error(regs->regs[10], &sf->uc.uc_mcontext.arm_r10, err);
430 	__put_user_error(regs->regs[11], &sf->uc.uc_mcontext.arm_fp, err);
431 	__put_user_error(regs->regs[12], &sf->uc.uc_mcontext.arm_ip, err);
432 	__put_user_error(regs->compat_sp, &sf->uc.uc_mcontext.arm_sp, err);
433 	__put_user_error(regs->compat_lr, &sf->uc.uc_mcontext.arm_lr, err);
434 	__put_user_error(regs->pc, &sf->uc.uc_mcontext.arm_pc, err);
435 	__put_user_error(regs->pstate, &sf->uc.uc_mcontext.arm_cpsr, err);
436 
437 	__put_user_error((compat_ulong_t)0, &sf->uc.uc_mcontext.trap_no, err);
438 	/* set the compat FSR WnR */
439 	__put_user_error(!!(current->thread.fault_code & ESR_ELx_WNR) <<
440 			 FSR_WRITE_SHIFT, &sf->uc.uc_mcontext.error_code, err);
441 	__put_user_error(current->thread.fault_address, &sf->uc.uc_mcontext.fault_address, err);
442 	__put_user_error(set->sig[0], &sf->uc.uc_mcontext.oldmask, err);
443 
444 	err |= put_sigset_t(&sf->uc.uc_sigmask, set);
445 
446 	aux = (struct compat_aux_sigframe __user *) sf->uc.uc_regspace;
447 
448 	if (err == 0)
449 		err |= compat_preserve_vfp_context(&aux->vfp);
450 	__put_user_error(0, &aux->end_magic, err);
451 
452 	return err;
453 }
454 
455 /*
456  * 32-bit signal handling routines called from signal.c
457  */
458 int compat_setup_rt_frame(int usig, struct ksignal *ksig,
459 			  sigset_t *set, struct pt_regs *regs)
460 {
461 	struct compat_rt_sigframe __user *frame;
462 	int err = 0;
463 
464 	frame = compat_get_sigframe(ksig, regs, sizeof(*frame));
465 
466 	if (!frame)
467 		return 1;
468 
469 	err |= copy_siginfo_to_user32(&frame->info, &ksig->info);
470 
471 	__put_user_error(0, &frame->sig.uc.uc_flags, err);
472 	__put_user_error(0, &frame->sig.uc.uc_link, err);
473 
474 	err |= __compat_save_altstack(&frame->sig.uc.uc_stack, regs->compat_sp);
475 
476 	err |= compat_setup_sigframe(&frame->sig, regs, set);
477 
478 	if (err == 0) {
479 		compat_setup_return(regs, &ksig->ka, frame->sig.retcode, frame, usig);
480 		regs->regs[1] = (compat_ulong_t)(unsigned long)&frame->info;
481 		regs->regs[2] = (compat_ulong_t)(unsigned long)&frame->sig.uc;
482 	}
483 
484 	return err;
485 }
486 
487 int compat_setup_frame(int usig, struct ksignal *ksig, sigset_t *set,
488 		       struct pt_regs *regs)
489 {
490 	struct compat_sigframe __user *frame;
491 	int err = 0;
492 
493 	frame = compat_get_sigframe(ksig, regs, sizeof(*frame));
494 
495 	if (!frame)
496 		return 1;
497 
498 	__put_user_error(0x5ac3c35a, &frame->uc.uc_flags, err);
499 
500 	err |= compat_setup_sigframe(frame, regs, set);
501 	if (err == 0)
502 		compat_setup_return(regs, &ksig->ka, frame->retcode, frame, usig);
503 
504 	return err;
505 }
506 
507 void compat_setup_restart_syscall(struct pt_regs *regs)
508 {
509        regs->regs[7] = __NR_compat_restart_syscall;
510 }
511