2 * Based on arch/arm/kernel/signal.c
4 * Copyright (C) 1995-2009 Russell King
5 * Copyright (C) 2012 ARM Ltd.
6 * Modified by Will Deacon <will.deacon@arm.com>
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.
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.
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/>.
21 #include <linux/compat.h>
22 #include <linux/signal.h>
23 #include <linux/syscalls.h>
24 #include <linux/ratelimit.h>
27 #include <asm/fpsimd.h>
28 #include <asm/signal32.h>
29 #include <linux/uaccess.h>
30 #include <asm/unistd.h>
32 struct compat_sigcontext
{
33 /* We always set these two fields to 0 */
34 compat_ulong_t trap_no
;
35 compat_ulong_t error_code
;
37 compat_ulong_t oldmask
;
38 compat_ulong_t arm_r0
;
39 compat_ulong_t arm_r1
;
40 compat_ulong_t arm_r2
;
41 compat_ulong_t arm_r3
;
42 compat_ulong_t arm_r4
;
43 compat_ulong_t arm_r5
;
44 compat_ulong_t arm_r6
;
45 compat_ulong_t arm_r7
;
46 compat_ulong_t arm_r8
;
47 compat_ulong_t arm_r9
;
48 compat_ulong_t arm_r10
;
49 compat_ulong_t arm_fp
;
50 compat_ulong_t arm_ip
;
51 compat_ulong_t arm_sp
;
52 compat_ulong_t arm_lr
;
53 compat_ulong_t arm_pc
;
54 compat_ulong_t arm_cpsr
;
55 compat_ulong_t fault_address
;
58 struct compat_ucontext
{
59 compat_ulong_t uc_flags
;
60 compat_uptr_t uc_link
;
61 compat_stack_t uc_stack
;
62 struct compat_sigcontext uc_mcontext
;
63 compat_sigset_t uc_sigmask
;
64 int __unused
[32 - (sizeof (compat_sigset_t
) / sizeof (int))];
65 compat_ulong_t uc_regspace
[128] __attribute__((__aligned__(8)));
68 struct compat_vfp_sigframe
{
71 struct compat_user_vfp
{
72 compat_u64 fpregs
[32];
75 struct compat_user_vfp_exc
{
77 compat_ulong_t fpinst
;
78 compat_ulong_t fpinst2
;
80 } __attribute__((__aligned__(8)));
82 #define VFP_MAGIC 0x56465001
83 #define VFP_STORAGE_SIZE sizeof(struct compat_vfp_sigframe)
85 #define FSR_WRITE_SHIFT (11)
87 struct compat_aux_sigframe
{
88 struct compat_vfp_sigframe vfp
;
90 /* Something that isn't a valid magic number for any coprocessor. */
91 unsigned long end_magic
;
92 } __attribute__((__aligned__(8)));
94 struct compat_sigframe
{
95 struct compat_ucontext uc
;
96 compat_ulong_t retcode
[2];
99 struct compat_rt_sigframe
{
100 struct compat_siginfo info
;
101 struct compat_sigframe sig
;
104 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
106 static inline int put_sigset_t(compat_sigset_t __user
*uset
, sigset_t
*set
)
108 compat_sigset_t cset
;
110 cset
.sig
[0] = set
->sig
[0] & 0xffffffffull
;
111 cset
.sig
[1] = set
->sig
[0] >> 32;
113 return copy_to_user(uset
, &cset
, sizeof(*uset
));
116 static inline int get_sigset_t(sigset_t
*set
,
117 const compat_sigset_t __user
*uset
)
121 if (copy_from_user(&s32
, uset
, sizeof(*uset
)))
124 set
->sig
[0] = s32
.sig
[0] | (((long)s32
.sig
[1]) << 32);
128 int copy_siginfo_to_user32(compat_siginfo_t __user
*to
, const siginfo_t
*from
)
132 if (!access_ok(VERIFY_WRITE
, to
, sizeof(*to
)))
135 /* If you change siginfo_t structure, please be sure
136 * this code is fixed accordingly.
137 * It should never copy any pad contained in the structure
138 * to avoid security leaks, but must copy the generic
139 * 3 ints plus the relevant union member.
140 * This routine must convert siginfo from 64bit to 32bit as well
143 err
= __put_user(from
->si_signo
, &to
->si_signo
);
144 err
|= __put_user(from
->si_errno
, &to
->si_errno
);
145 err
|= __put_user(from
->si_code
, &to
->si_code
);
146 if (from
->si_code
< 0)
147 err
|= __copy_to_user(&to
->_sifields
._pad
, &from
->_sifields
._pad
,
149 else switch (siginfo_layout(from
->si_signo
, from
->si_code
)) {
151 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
152 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
155 err
|= __put_user(from
->si_tid
, &to
->si_tid
);
156 err
|= __put_user(from
->si_overrun
, &to
->si_overrun
);
157 err
|= __put_user(from
->si_int
, &to
->si_int
);
160 err
|= __put_user(from
->si_band
, &to
->si_band
);
161 err
|= __put_user(from
->si_fd
, &to
->si_fd
);
164 err
|= __put_user((compat_uptr_t
)(unsigned long)from
->si_addr
,
168 * Other callers might not initialize the si_lsb field,
169 * so check explicitly for the right codes here.
171 if (from
->si_signo
== SIGBUS
&&
172 (from
->si_code
== BUS_MCEERR_AR
|| from
->si_code
== BUS_MCEERR_AO
))
173 err
|= __put_user(from
->si_addr_lsb
, &to
->si_addr_lsb
);
177 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
178 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
179 err
|= __put_user(from
->si_status
, &to
->si_status
);
180 err
|= __put_user(from
->si_utime
, &to
->si_utime
);
181 err
|= __put_user(from
->si_stime
, &to
->si_stime
);
184 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
185 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
186 err
|= __put_user(from
->si_int
, &to
->si_int
);
189 err
|= __put_user((compat_uptr_t
)(unsigned long)
190 from
->si_call_addr
, &to
->si_call_addr
);
191 err
|= __put_user(from
->si_syscall
, &to
->si_syscall
);
192 err
|= __put_user(from
->si_arch
, &to
->si_arch
);
198 int copy_siginfo_from_user32(siginfo_t
*to
, compat_siginfo_t __user
*from
)
200 if (copy_from_user(to
, from
, __ARCH_SI_PREAMBLE_SIZE
) ||
201 copy_from_user(to
->_sifields
._pad
,
202 from
->_sifields
._pad
, SI_PAD_SIZE
))
209 * VFP save/restore code.
211 * We have to be careful with endianness, since the fpsimd context-switch
212 * code operates on 128-bit (Q) register values whereas the compat ABI
213 * uses an array of 64-bit (D) registers. Consequently, we need to swap
214 * the two halves of each Q register when running on a big-endian CPU.
216 union __fpsimd_vreg
{
229 static int compat_preserve_vfp_context(struct compat_vfp_sigframe __user
*frame
)
231 struct fpsimd_state
*fpsimd
= ¤t
->thread
.fpsimd_state
;
232 compat_ulong_t magic
= VFP_MAGIC
;
233 compat_ulong_t size
= VFP_STORAGE_SIZE
;
234 compat_ulong_t fpscr
, fpexc
;
238 * Save the hardware registers to the fpsimd_state structure.
239 * Note that this also saves V16-31, which aren't visible
242 fpsimd_preserve_current_state();
244 /* Place structure header on the stack */
245 __put_user_error(magic
, &frame
->magic
, err
);
246 __put_user_error(size
, &frame
->size
, err
);
249 * Now copy the FP registers. Since the registers are packed,
250 * we can copy the prefix we want (V0-V15) as it is.
252 for (i
= 0; i
< ARRAY_SIZE(frame
->ufp
.fpregs
); i
+= 2) {
253 union __fpsimd_vreg vreg
= {
254 .raw
= fpsimd
->vregs
[i
>> 1],
257 __put_user_error(vreg
.lo
, &frame
->ufp
.fpregs
[i
], err
);
258 __put_user_error(vreg
.hi
, &frame
->ufp
.fpregs
[i
+ 1], err
);
261 /* Create an AArch32 fpscr from the fpsr and the fpcr. */
262 fpscr
= (fpsimd
->fpsr
& VFP_FPSCR_STAT_MASK
) |
263 (fpsimd
->fpcr
& VFP_FPSCR_CTRL_MASK
);
264 __put_user_error(fpscr
, &frame
->ufp
.fpscr
, err
);
267 * The exception register aren't available so we fake up a
268 * basic FPEXC and zero everything else.
271 __put_user_error(fpexc
, &frame
->ufp_exc
.fpexc
, err
);
272 __put_user_error(0, &frame
->ufp_exc
.fpinst
, err
);
273 __put_user_error(0, &frame
->ufp_exc
.fpinst2
, err
);
275 return err
? -EFAULT
: 0;
278 static int compat_restore_vfp_context(struct compat_vfp_sigframe __user
*frame
)
280 struct fpsimd_state fpsimd
;
281 compat_ulong_t magic
= VFP_MAGIC
;
282 compat_ulong_t size
= VFP_STORAGE_SIZE
;
283 compat_ulong_t fpscr
;
286 __get_user_error(magic
, &frame
->magic
, err
);
287 __get_user_error(size
, &frame
->size
, err
);
291 if (magic
!= VFP_MAGIC
|| size
!= VFP_STORAGE_SIZE
)
294 /* Copy the FP registers into the start of the fpsimd_state. */
295 for (i
= 0; i
< ARRAY_SIZE(frame
->ufp
.fpregs
); i
+= 2) {
296 union __fpsimd_vreg vreg
;
298 __get_user_error(vreg
.lo
, &frame
->ufp
.fpregs
[i
], err
);
299 __get_user_error(vreg
.hi
, &frame
->ufp
.fpregs
[i
+ 1], err
);
300 fpsimd
.vregs
[i
>> 1] = vreg
.raw
;
303 /* Extract the fpsr and the fpcr from the fpscr */
304 __get_user_error(fpscr
, &frame
->ufp
.fpscr
, err
);
305 fpsimd
.fpsr
= fpscr
& VFP_FPSCR_STAT_MASK
;
306 fpsimd
.fpcr
= fpscr
& VFP_FPSCR_CTRL_MASK
;
309 * We don't need to touch the exception register, so
310 * reload the hardware state.
313 fpsimd_update_current_state(&fpsimd
);
315 return err
? -EFAULT
: 0;
318 static int compat_restore_sigframe(struct pt_regs
*regs
,
319 struct compat_sigframe __user
*sf
)
323 struct compat_aux_sigframe __user
*aux
;
325 err
= get_sigset_t(&set
, &sf
->uc
.uc_sigmask
);
327 sigdelsetmask(&set
, ~_BLOCKABLE
);
328 set_current_blocked(&set
);
331 __get_user_error(regs
->regs
[0], &sf
->uc
.uc_mcontext
.arm_r0
, err
);
332 __get_user_error(regs
->regs
[1], &sf
->uc
.uc_mcontext
.arm_r1
, err
);
333 __get_user_error(regs
->regs
[2], &sf
->uc
.uc_mcontext
.arm_r2
, err
);
334 __get_user_error(regs
->regs
[3], &sf
->uc
.uc_mcontext
.arm_r3
, err
);
335 __get_user_error(regs
->regs
[4], &sf
->uc
.uc_mcontext
.arm_r4
, err
);
336 __get_user_error(regs
->regs
[5], &sf
->uc
.uc_mcontext
.arm_r5
, err
);
337 __get_user_error(regs
->regs
[6], &sf
->uc
.uc_mcontext
.arm_r6
, err
);
338 __get_user_error(regs
->regs
[7], &sf
->uc
.uc_mcontext
.arm_r7
, err
);
339 __get_user_error(regs
->regs
[8], &sf
->uc
.uc_mcontext
.arm_r8
, err
);
340 __get_user_error(regs
->regs
[9], &sf
->uc
.uc_mcontext
.arm_r9
, err
);
341 __get_user_error(regs
->regs
[10], &sf
->uc
.uc_mcontext
.arm_r10
, err
);
342 __get_user_error(regs
->regs
[11], &sf
->uc
.uc_mcontext
.arm_fp
, err
);
343 __get_user_error(regs
->regs
[12], &sf
->uc
.uc_mcontext
.arm_ip
, err
);
344 __get_user_error(regs
->compat_sp
, &sf
->uc
.uc_mcontext
.arm_sp
, err
);
345 __get_user_error(regs
->compat_lr
, &sf
->uc
.uc_mcontext
.arm_lr
, err
);
346 __get_user_error(regs
->pc
, &sf
->uc
.uc_mcontext
.arm_pc
, err
);
347 __get_user_error(regs
->pstate
, &sf
->uc
.uc_mcontext
.arm_cpsr
, err
);
350 * Avoid compat_sys_sigreturn() restarting.
352 forget_syscall(regs
);
354 err
|= !valid_user_regs(®s
->user_regs
, current
);
356 aux
= (struct compat_aux_sigframe __user
*) sf
->uc
.uc_regspace
;
358 err
|= compat_restore_vfp_context(&aux
->vfp
);
363 asmlinkage
int compat_sys_sigreturn(struct pt_regs
*regs
)
365 struct compat_sigframe __user
*frame
;
367 /* Always make any pending restarted system calls return -EINTR */
368 current
->restart_block
.fn
= do_no_restart_syscall
;
371 * Since we stacked the signal on a 64-bit boundary,
372 * then 'sp' should be word aligned here. If it's
373 * not, then the user is trying to mess with us.
375 if (regs
->compat_sp
& 7)
378 frame
= (struct compat_sigframe __user
*)regs
->compat_sp
;
380 if (!access_ok(VERIFY_READ
, frame
, sizeof (*frame
)))
383 if (compat_restore_sigframe(regs
, frame
))
386 return regs
->regs
[0];
389 if (show_unhandled_signals
)
390 pr_info_ratelimited("%s[%d]: bad frame in %s: pc=%08llx sp=%08llx\n",
391 current
->comm
, task_pid_nr(current
), __func__
,
392 regs
->pc
, regs
->compat_sp
);
393 force_sig(SIGSEGV
, current
);
397 asmlinkage
int compat_sys_rt_sigreturn(struct pt_regs
*regs
)
399 struct compat_rt_sigframe __user
*frame
;
401 /* Always make any pending restarted system calls return -EINTR */
402 current
->restart_block
.fn
= do_no_restart_syscall
;
405 * Since we stacked the signal on a 64-bit boundary,
406 * then 'sp' should be word aligned here. If it's
407 * not, then the user is trying to mess with us.
409 if (regs
->compat_sp
& 7)
412 frame
= (struct compat_rt_sigframe __user
*)regs
->compat_sp
;
414 if (!access_ok(VERIFY_READ
, frame
, sizeof (*frame
)))
417 if (compat_restore_sigframe(regs
, &frame
->sig
))
420 if (compat_restore_altstack(&frame
->sig
.uc
.uc_stack
))
423 return regs
->regs
[0];
426 if (show_unhandled_signals
)
427 pr_info_ratelimited("%s[%d]: bad frame in %s: pc=%08llx sp=%08llx\n",
428 current
->comm
, task_pid_nr(current
), __func__
,
429 regs
->pc
, regs
->compat_sp
);
430 force_sig(SIGSEGV
, current
);
434 static void __user
*compat_get_sigframe(struct ksignal
*ksig
,
435 struct pt_regs
*regs
,
438 compat_ulong_t sp
= sigsp(regs
->compat_sp
, ksig
);
442 * ATPCS B01 mandates 8-byte alignment
444 frame
= compat_ptr((compat_uptr_t
)((sp
- framesize
) & ~7));
447 * Check that we can actually write to the signal frame.
449 if (!access_ok(VERIFY_WRITE
, frame
, framesize
))
455 static void compat_setup_return(struct pt_regs
*regs
, struct k_sigaction
*ka
,
456 compat_ulong_t __user
*rc
, void __user
*frame
,
459 compat_ulong_t handler
= ptr_to_compat(ka
->sa
.sa_handler
);
460 compat_ulong_t retcode
;
461 compat_ulong_t spsr
= regs
->pstate
& ~(PSR_f
| COMPAT_PSR_E_BIT
);
464 /* Check if the handler is written for ARM or Thumb */
468 spsr
|= COMPAT_PSR_T_BIT
;
470 spsr
&= ~COMPAT_PSR_T_BIT
;
472 /* The IT state must be cleared for both ARM and Thumb-2 */
473 spsr
&= ~COMPAT_PSR_IT_MASK
;
475 /* Restore the original endianness */
476 spsr
|= COMPAT_PSR_ENDSTATE
;
478 if (ka
->sa
.sa_flags
& SA_RESTORER
) {
479 retcode
= ptr_to_compat(ka
->sa
.sa_restorer
);
481 /* Set up sigreturn pointer */
482 unsigned int idx
= thumb
<< 1;
484 if (ka
->sa
.sa_flags
& SA_SIGINFO
)
487 retcode
= AARCH32_VECTORS_BASE
+
488 AARCH32_KERN_SIGRET_CODE_OFFSET
+
492 regs
->regs
[0] = usig
;
493 regs
->compat_sp
= ptr_to_compat(frame
);
494 regs
->compat_lr
= retcode
;
499 static int compat_setup_sigframe(struct compat_sigframe __user
*sf
,
500 struct pt_regs
*regs
, sigset_t
*set
)
502 struct compat_aux_sigframe __user
*aux
;
505 __put_user_error(regs
->regs
[0], &sf
->uc
.uc_mcontext
.arm_r0
, err
);
506 __put_user_error(regs
->regs
[1], &sf
->uc
.uc_mcontext
.arm_r1
, err
);
507 __put_user_error(regs
->regs
[2], &sf
->uc
.uc_mcontext
.arm_r2
, err
);
508 __put_user_error(regs
->regs
[3], &sf
->uc
.uc_mcontext
.arm_r3
, err
);
509 __put_user_error(regs
->regs
[4], &sf
->uc
.uc_mcontext
.arm_r4
, err
);
510 __put_user_error(regs
->regs
[5], &sf
->uc
.uc_mcontext
.arm_r5
, err
);
511 __put_user_error(regs
->regs
[6], &sf
->uc
.uc_mcontext
.arm_r6
, err
);
512 __put_user_error(regs
->regs
[7], &sf
->uc
.uc_mcontext
.arm_r7
, err
);
513 __put_user_error(regs
->regs
[8], &sf
->uc
.uc_mcontext
.arm_r8
, err
);
514 __put_user_error(regs
->regs
[9], &sf
->uc
.uc_mcontext
.arm_r9
, err
);
515 __put_user_error(regs
->regs
[10], &sf
->uc
.uc_mcontext
.arm_r10
, err
);
516 __put_user_error(regs
->regs
[11], &sf
->uc
.uc_mcontext
.arm_fp
, err
);
517 __put_user_error(regs
->regs
[12], &sf
->uc
.uc_mcontext
.arm_ip
, err
);
518 __put_user_error(regs
->compat_sp
, &sf
->uc
.uc_mcontext
.arm_sp
, err
);
519 __put_user_error(regs
->compat_lr
, &sf
->uc
.uc_mcontext
.arm_lr
, err
);
520 __put_user_error(regs
->pc
, &sf
->uc
.uc_mcontext
.arm_pc
, err
);
521 __put_user_error(regs
->pstate
, &sf
->uc
.uc_mcontext
.arm_cpsr
, err
);
523 __put_user_error((compat_ulong_t
)0, &sf
->uc
.uc_mcontext
.trap_no
, err
);
524 /* set the compat FSR WnR */
525 __put_user_error(!!(current
->thread
.fault_code
& ESR_ELx_WNR
) <<
526 FSR_WRITE_SHIFT
, &sf
->uc
.uc_mcontext
.error_code
, err
);
527 __put_user_error(current
->thread
.fault_address
, &sf
->uc
.uc_mcontext
.fault_address
, err
);
528 __put_user_error(set
->sig
[0], &sf
->uc
.uc_mcontext
.oldmask
, err
);
530 err
|= put_sigset_t(&sf
->uc
.uc_sigmask
, set
);
532 aux
= (struct compat_aux_sigframe __user
*) sf
->uc
.uc_regspace
;
535 err
|= compat_preserve_vfp_context(&aux
->vfp
);
536 __put_user_error(0, &aux
->end_magic
, err
);
542 * 32-bit signal handling routines called from signal.c
544 int compat_setup_rt_frame(int usig
, struct ksignal
*ksig
,
545 sigset_t
*set
, struct pt_regs
*regs
)
547 struct compat_rt_sigframe __user
*frame
;
550 frame
= compat_get_sigframe(ksig
, regs
, sizeof(*frame
));
555 err
|= copy_siginfo_to_user32(&frame
->info
, &ksig
->info
);
557 __put_user_error(0, &frame
->sig
.uc
.uc_flags
, err
);
558 __put_user_error(0, &frame
->sig
.uc
.uc_link
, err
);
560 err
|= __compat_save_altstack(&frame
->sig
.uc
.uc_stack
, regs
->compat_sp
);
562 err
|= compat_setup_sigframe(&frame
->sig
, regs
, set
);
565 compat_setup_return(regs
, &ksig
->ka
, frame
->sig
.retcode
, frame
, usig
);
566 regs
->regs
[1] = (compat_ulong_t
)(unsigned long)&frame
->info
;
567 regs
->regs
[2] = (compat_ulong_t
)(unsigned long)&frame
->sig
.uc
;
573 int compat_setup_frame(int usig
, struct ksignal
*ksig
, sigset_t
*set
,
574 struct pt_regs
*regs
)
576 struct compat_sigframe __user
*frame
;
579 frame
= compat_get_sigframe(ksig
, regs
, sizeof(*frame
));
584 __put_user_error(0x5ac3c35a, &frame
->uc
.uc_flags
, err
);
586 err
|= compat_setup_sigframe(frame
, regs
, set
);
588 compat_setup_return(regs
, &ksig
->ka
, frame
->retcode
, frame
, usig
);
593 void compat_setup_restart_syscall(struct pt_regs
*regs
)
595 regs
->regs
[7] = __NR_compat_restart_syscall
;