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>
26 #include <asm/fpsimd.h>
27 #include <asm/signal32.h>
28 #include <asm/uaccess.h>
29 #include <asm/unistd32.h>
31 struct compat_sigcontext
{
32 /* We always set these two fields to 0 */
33 compat_ulong_t trap_no
;
34 compat_ulong_t error_code
;
36 compat_ulong_t oldmask
;
37 compat_ulong_t arm_r0
;
38 compat_ulong_t arm_r1
;
39 compat_ulong_t arm_r2
;
40 compat_ulong_t arm_r3
;
41 compat_ulong_t arm_r4
;
42 compat_ulong_t arm_r5
;
43 compat_ulong_t arm_r6
;
44 compat_ulong_t arm_r7
;
45 compat_ulong_t arm_r8
;
46 compat_ulong_t arm_r9
;
47 compat_ulong_t arm_r10
;
48 compat_ulong_t arm_fp
;
49 compat_ulong_t arm_ip
;
50 compat_ulong_t arm_sp
;
51 compat_ulong_t arm_lr
;
52 compat_ulong_t arm_pc
;
53 compat_ulong_t arm_cpsr
;
54 compat_ulong_t fault_address
;
57 struct compat_ucontext
{
58 compat_ulong_t uc_flags
;
59 compat_uptr_t uc_link
;
60 compat_stack_t uc_stack
;
61 struct compat_sigcontext uc_mcontext
;
62 compat_sigset_t uc_sigmask
;
63 int __unused
[32 - (sizeof (compat_sigset_t
) / sizeof (int))];
64 compat_ulong_t uc_regspace
[128] __attribute__((__aligned__(8)));
67 struct compat_vfp_sigframe
{
70 struct compat_user_vfp
{
71 compat_u64 fpregs
[32];
74 struct compat_user_vfp_exc
{
76 compat_ulong_t fpinst
;
77 compat_ulong_t fpinst2
;
79 } __attribute__((__aligned__(8)));
81 #define VFP_MAGIC 0x56465001
82 #define VFP_STORAGE_SIZE sizeof(struct compat_vfp_sigframe)
84 struct compat_aux_sigframe
{
85 struct compat_vfp_sigframe vfp
;
87 /* Something that isn't a valid magic number for any coprocessor. */
88 unsigned long end_magic
;
89 } __attribute__((__aligned__(8)));
91 struct compat_sigframe
{
92 struct compat_ucontext uc
;
93 compat_ulong_t retcode
[2];
96 struct compat_rt_sigframe
{
97 struct compat_siginfo info
;
98 struct compat_sigframe sig
;
101 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
103 static inline int put_sigset_t(compat_sigset_t __user
*uset
, sigset_t
*set
)
105 compat_sigset_t cset
;
107 cset
.sig
[0] = set
->sig
[0] & 0xffffffffull
;
108 cset
.sig
[1] = set
->sig
[0] >> 32;
110 return copy_to_user(uset
, &cset
, sizeof(*uset
));
113 static inline int get_sigset_t(sigset_t
*set
,
114 const compat_sigset_t __user
*uset
)
118 if (copy_from_user(&s32
, uset
, sizeof(*uset
)))
121 set
->sig
[0] = s32
.sig
[0] | (((long)s32
.sig
[1]) << 32);
125 int copy_siginfo_to_user32(compat_siginfo_t __user
*to
, siginfo_t
*from
)
129 if (!access_ok(VERIFY_WRITE
, to
, sizeof(*to
)))
132 /* If you change siginfo_t structure, please be sure
133 * this code is fixed accordingly.
134 * It should never copy any pad contained in the structure
135 * to avoid security leaks, but must copy the generic
136 * 3 ints plus the relevant union member.
137 * This routine must convert siginfo from 64bit to 32bit as well
140 err
= __put_user(from
->si_signo
, &to
->si_signo
);
141 err
|= __put_user(from
->si_errno
, &to
->si_errno
);
142 err
|= __put_user((short)from
->si_code
, &to
->si_code
);
143 if (from
->si_code
< 0)
144 err
|= __copy_to_user(&to
->_sifields
._pad
, &from
->_sifields
._pad
,
146 else switch (from
->si_code
& __SI_MASK
) {
148 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
149 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
152 err
|= __put_user(from
->si_tid
, &to
->si_tid
);
153 err
|= __put_user(from
->si_overrun
, &to
->si_overrun
);
154 err
|= __put_user((compat_uptr_t
)(unsigned long)from
->si_ptr
,
158 err
|= __put_user(from
->si_band
, &to
->si_band
);
159 err
|= __put_user(from
->si_fd
, &to
->si_fd
);
162 err
|= __put_user((compat_uptr_t
)(unsigned long)from
->si_addr
,
166 * Other callers might not initialize the si_lsb field,
167 * so check explicitely for the right codes here.
169 if (from
->si_code
== BUS_MCEERR_AR
|| from
->si_code
== BUS_MCEERR_AO
)
170 err
|= __put_user(from
->si_addr_lsb
, &to
->si_addr_lsb
);
174 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
175 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
176 err
|= __put_user(from
->si_status
, &to
->si_status
);
177 err
|= __put_user(from
->si_utime
, &to
->si_utime
);
178 err
|= __put_user(from
->si_stime
, &to
->si_stime
);
180 case __SI_RT
: /* This is not generated by the kernel as of now. */
181 case __SI_MESGQ
: /* But this is */
182 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
183 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
184 err
|= __put_user((compat_uptr_t
)(unsigned long)from
->si_ptr
, &to
->si_ptr
);
186 default: /* this is just in case for now ... */
187 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
188 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
194 int copy_siginfo_from_user32(siginfo_t
*to
, compat_siginfo_t __user
*from
)
196 memset(to
, 0, sizeof *to
);
198 if (copy_from_user(to
, from
, __ARCH_SI_PREAMBLE_SIZE
) ||
199 copy_from_user(to
->_sifields
._pad
,
200 from
->_sifields
._pad
, SI_PAD_SIZE
))
207 * VFP save/restore code.
209 static int compat_preserve_vfp_context(struct compat_vfp_sigframe __user
*frame
)
211 struct fpsimd_state
*fpsimd
= ¤t
->thread
.fpsimd_state
;
212 compat_ulong_t magic
= VFP_MAGIC
;
213 compat_ulong_t size
= VFP_STORAGE_SIZE
;
214 compat_ulong_t fpscr
, fpexc
;
218 * Save the hardware registers to the fpsimd_state structure.
219 * Note that this also saves V16-31, which aren't visible
222 fpsimd_save_state(fpsimd
);
224 /* Place structure header on the stack */
225 __put_user_error(magic
, &frame
->magic
, err
);
226 __put_user_error(size
, &frame
->size
, err
);
229 * Now copy the FP registers. Since the registers are packed,
230 * we can copy the prefix we want (V0-V15) as it is.
231 * FIXME: Won't work if big endian.
233 err
|= __copy_to_user(&frame
->ufp
.fpregs
, fpsimd
->vregs
,
234 sizeof(frame
->ufp
.fpregs
));
236 /* Create an AArch32 fpscr from the fpsr and the fpcr. */
237 fpscr
= (fpsimd
->fpsr
& VFP_FPSCR_STAT_MASK
) |
238 (fpsimd
->fpcr
& VFP_FPSCR_CTRL_MASK
);
239 __put_user_error(fpscr
, &frame
->ufp
.fpscr
, err
);
242 * The exception register aren't available so we fake up a
243 * basic FPEXC and zero everything else.
246 __put_user_error(fpexc
, &frame
->ufp_exc
.fpexc
, err
);
247 __put_user_error(0, &frame
->ufp_exc
.fpinst
, err
);
248 __put_user_error(0, &frame
->ufp_exc
.fpinst2
, err
);
250 return err
? -EFAULT
: 0;
253 static int compat_restore_vfp_context(struct compat_vfp_sigframe __user
*frame
)
255 struct fpsimd_state fpsimd
;
256 compat_ulong_t magic
= VFP_MAGIC
;
257 compat_ulong_t size
= VFP_STORAGE_SIZE
;
258 compat_ulong_t fpscr
;
261 __get_user_error(magic
, &frame
->magic
, err
);
262 __get_user_error(size
, &frame
->size
, err
);
266 if (magic
!= VFP_MAGIC
|| size
!= VFP_STORAGE_SIZE
)
270 * Copy the FP registers into the start of the fpsimd_state.
271 * FIXME: Won't work if big endian.
273 err
|= __copy_from_user(fpsimd
.vregs
, frame
->ufp
.fpregs
,
274 sizeof(frame
->ufp
.fpregs
));
276 /* Extract the fpsr and the fpcr from the fpscr */
277 __get_user_error(fpscr
, &frame
->ufp
.fpscr
, err
);
278 fpsimd
.fpsr
= fpscr
& VFP_FPSCR_STAT_MASK
;
279 fpsimd
.fpcr
= fpscr
& VFP_FPSCR_CTRL_MASK
;
282 * We don't need to touch the exception register, so
283 * reload the hardware state.
287 fpsimd_load_state(&fpsimd
);
291 return err
? -EFAULT
: 0;
294 static int compat_restore_sigframe(struct pt_regs
*regs
,
295 struct compat_sigframe __user
*sf
)
299 struct compat_aux_sigframe __user
*aux
;
301 err
= get_sigset_t(&set
, &sf
->uc
.uc_sigmask
);
303 sigdelsetmask(&set
, ~_BLOCKABLE
);
304 set_current_blocked(&set
);
307 __get_user_error(regs
->regs
[0], &sf
->uc
.uc_mcontext
.arm_r0
, err
);
308 __get_user_error(regs
->regs
[1], &sf
->uc
.uc_mcontext
.arm_r1
, err
);
309 __get_user_error(regs
->regs
[2], &sf
->uc
.uc_mcontext
.arm_r2
, err
);
310 __get_user_error(regs
->regs
[3], &sf
->uc
.uc_mcontext
.arm_r3
, err
);
311 __get_user_error(regs
->regs
[4], &sf
->uc
.uc_mcontext
.arm_r4
, err
);
312 __get_user_error(regs
->regs
[5], &sf
->uc
.uc_mcontext
.arm_r5
, err
);
313 __get_user_error(regs
->regs
[6], &sf
->uc
.uc_mcontext
.arm_r6
, err
);
314 __get_user_error(regs
->regs
[7], &sf
->uc
.uc_mcontext
.arm_r7
, err
);
315 __get_user_error(regs
->regs
[8], &sf
->uc
.uc_mcontext
.arm_r8
, err
);
316 __get_user_error(regs
->regs
[9], &sf
->uc
.uc_mcontext
.arm_r9
, err
);
317 __get_user_error(regs
->regs
[10], &sf
->uc
.uc_mcontext
.arm_r10
, err
);
318 __get_user_error(regs
->regs
[11], &sf
->uc
.uc_mcontext
.arm_fp
, err
);
319 __get_user_error(regs
->regs
[12], &sf
->uc
.uc_mcontext
.arm_ip
, err
);
320 __get_user_error(regs
->compat_sp
, &sf
->uc
.uc_mcontext
.arm_sp
, err
);
321 __get_user_error(regs
->compat_lr
, &sf
->uc
.uc_mcontext
.arm_lr
, err
);
322 __get_user_error(regs
->pc
, &sf
->uc
.uc_mcontext
.arm_pc
, err
);
323 __get_user_error(regs
->pstate
, &sf
->uc
.uc_mcontext
.arm_cpsr
, err
);
326 * Avoid compat_sys_sigreturn() restarting.
328 regs
->syscallno
= ~0UL;
330 err
|= !valid_user_regs(®s
->user_regs
);
332 aux
= (struct compat_aux_sigframe __user
*) sf
->uc
.uc_regspace
;
334 err
|= compat_restore_vfp_context(&aux
->vfp
);
339 asmlinkage
int compat_sys_sigreturn(struct pt_regs
*regs
)
341 struct compat_sigframe __user
*frame
;
343 /* Always make any pending restarted system calls return -EINTR */
344 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
347 * Since we stacked the signal on a 64-bit boundary,
348 * then 'sp' should be word aligned here. If it's
349 * not, then the user is trying to mess with us.
351 if (regs
->compat_sp
& 7)
354 frame
= (struct compat_sigframe __user
*)regs
->compat_sp
;
356 if (!access_ok(VERIFY_READ
, frame
, sizeof (*frame
)))
359 if (compat_restore_sigframe(regs
, frame
))
362 return regs
->regs
[0];
365 if (show_unhandled_signals
)
366 pr_info_ratelimited("%s[%d]: bad frame in %s: pc=%08llx sp=%08llx\n",
367 current
->comm
, task_pid_nr(current
), __func__
,
369 force_sig(SIGSEGV
, current
);
373 asmlinkage
int compat_sys_rt_sigreturn(struct pt_regs
*regs
)
375 struct compat_rt_sigframe __user
*frame
;
377 /* Always make any pending restarted system calls return -EINTR */
378 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
381 * Since we stacked the signal on a 64-bit boundary,
382 * then 'sp' should be word aligned here. If it's
383 * not, then the user is trying to mess with us.
385 if (regs
->compat_sp
& 7)
388 frame
= (struct compat_rt_sigframe __user
*)regs
->compat_sp
;
390 if (!access_ok(VERIFY_READ
, frame
, sizeof (*frame
)))
393 if (compat_restore_sigframe(regs
, &frame
->sig
))
396 if (compat_restore_altstack(&frame
->sig
.uc
.uc_stack
))
399 return regs
->regs
[0];
402 if (show_unhandled_signals
)
403 pr_info_ratelimited("%s[%d]: bad frame in %s: pc=%08llx sp=%08llx\n",
404 current
->comm
, task_pid_nr(current
), __func__
,
406 force_sig(SIGSEGV
, current
);
410 static void __user
*compat_get_sigframe(struct k_sigaction
*ka
,
411 struct pt_regs
*regs
,
414 compat_ulong_t sp
= regs
->compat_sp
;
418 * This is the X/Open sanctioned signal stack switching.
420 if ((ka
->sa
.sa_flags
& SA_ONSTACK
) && !sas_ss_flags(sp
))
421 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
424 * ATPCS B01 mandates 8-byte alignment
426 frame
= compat_ptr((compat_uptr_t
)((sp
- framesize
) & ~7));
429 * Check that we can actually write to the signal frame.
431 if (!access_ok(VERIFY_WRITE
, frame
, framesize
))
437 static void compat_setup_return(struct pt_regs
*regs
, struct k_sigaction
*ka
,
438 compat_ulong_t __user
*rc
, void __user
*frame
,
441 compat_ulong_t handler
= ptr_to_compat(ka
->sa
.sa_handler
);
442 compat_ulong_t retcode
;
443 compat_ulong_t spsr
= regs
->pstate
& ~PSR_f
;
446 /* Check if the handler is written for ARM or Thumb */
450 spsr
|= COMPAT_PSR_T_BIT
;
452 spsr
&= ~COMPAT_PSR_T_BIT
;
454 /* The IT state must be cleared for both ARM and Thumb-2 */
455 spsr
&= ~COMPAT_PSR_IT_MASK
;
457 if (ka
->sa
.sa_flags
& SA_RESTORER
) {
458 retcode
= ptr_to_compat(ka
->sa
.sa_restorer
);
460 /* Set up sigreturn pointer */
461 unsigned int idx
= thumb
<< 1;
463 if (ka
->sa
.sa_flags
& SA_SIGINFO
)
466 retcode
= AARCH32_VECTORS_BASE
+
467 AARCH32_KERN_SIGRET_CODE_OFFSET
+
471 regs
->regs
[0] = usig
;
472 regs
->compat_sp
= ptr_to_compat(frame
);
473 regs
->compat_lr
= retcode
;
478 static int compat_setup_sigframe(struct compat_sigframe __user
*sf
,
479 struct pt_regs
*regs
, sigset_t
*set
)
481 struct compat_aux_sigframe __user
*aux
;
484 __put_user_error(regs
->regs
[0], &sf
->uc
.uc_mcontext
.arm_r0
, err
);
485 __put_user_error(regs
->regs
[1], &sf
->uc
.uc_mcontext
.arm_r1
, err
);
486 __put_user_error(regs
->regs
[2], &sf
->uc
.uc_mcontext
.arm_r2
, err
);
487 __put_user_error(regs
->regs
[3], &sf
->uc
.uc_mcontext
.arm_r3
, err
);
488 __put_user_error(regs
->regs
[4], &sf
->uc
.uc_mcontext
.arm_r4
, err
);
489 __put_user_error(regs
->regs
[5], &sf
->uc
.uc_mcontext
.arm_r5
, err
);
490 __put_user_error(regs
->regs
[6], &sf
->uc
.uc_mcontext
.arm_r6
, err
);
491 __put_user_error(regs
->regs
[7], &sf
->uc
.uc_mcontext
.arm_r7
, err
);
492 __put_user_error(regs
->regs
[8], &sf
->uc
.uc_mcontext
.arm_r8
, err
);
493 __put_user_error(regs
->regs
[9], &sf
->uc
.uc_mcontext
.arm_r9
, err
);
494 __put_user_error(regs
->regs
[10], &sf
->uc
.uc_mcontext
.arm_r10
, err
);
495 __put_user_error(regs
->regs
[11], &sf
->uc
.uc_mcontext
.arm_fp
, err
);
496 __put_user_error(regs
->regs
[12], &sf
->uc
.uc_mcontext
.arm_ip
, err
);
497 __put_user_error(regs
->compat_sp
, &sf
->uc
.uc_mcontext
.arm_sp
, err
);
498 __put_user_error(regs
->compat_lr
, &sf
->uc
.uc_mcontext
.arm_lr
, err
);
499 __put_user_error(regs
->pc
, &sf
->uc
.uc_mcontext
.arm_pc
, err
);
500 __put_user_error(regs
->pstate
, &sf
->uc
.uc_mcontext
.arm_cpsr
, err
);
502 __put_user_error((compat_ulong_t
)0, &sf
->uc
.uc_mcontext
.trap_no
, err
);
503 __put_user_error((compat_ulong_t
)0, &sf
->uc
.uc_mcontext
.error_code
, err
);
504 __put_user_error(current
->thread
.fault_address
, &sf
->uc
.uc_mcontext
.fault_address
, err
);
505 __put_user_error(set
->sig
[0], &sf
->uc
.uc_mcontext
.oldmask
, err
);
507 err
|= put_sigset_t(&sf
->uc
.uc_sigmask
, set
);
509 aux
= (struct compat_aux_sigframe __user
*) sf
->uc
.uc_regspace
;
512 err
|= compat_preserve_vfp_context(&aux
->vfp
);
513 __put_user_error(0, &aux
->end_magic
, err
);
519 * 32-bit signal handling routines called from signal.c
521 int compat_setup_rt_frame(int usig
, struct k_sigaction
*ka
, siginfo_t
*info
,
522 sigset_t
*set
, struct pt_regs
*regs
)
524 struct compat_rt_sigframe __user
*frame
;
527 frame
= compat_get_sigframe(ka
, regs
, sizeof(*frame
));
532 err
|= copy_siginfo_to_user32(&frame
->info
, info
);
534 __put_user_error(0, &frame
->sig
.uc
.uc_flags
, err
);
535 __put_user_error(0, &frame
->sig
.uc
.uc_link
, err
);
537 err
|= __compat_save_altstack(&frame
->sig
.uc
.uc_stack
, regs
->compat_sp
);
539 err
|= compat_setup_sigframe(&frame
->sig
, regs
, set
);
542 compat_setup_return(regs
, ka
, frame
->sig
.retcode
, frame
, usig
);
543 regs
->regs
[1] = (compat_ulong_t
)(unsigned long)&frame
->info
;
544 regs
->regs
[2] = (compat_ulong_t
)(unsigned long)&frame
->sig
.uc
;
550 int compat_setup_frame(int usig
, struct k_sigaction
*ka
, sigset_t
*set
,
551 struct pt_regs
*regs
)
553 struct compat_sigframe __user
*frame
;
556 frame
= compat_get_sigframe(ka
, regs
, sizeof(*frame
));
561 __put_user_error(0x5ac3c35a, &frame
->uc
.uc_flags
, err
);
563 err
|= compat_setup_sigframe(frame
, regs
, set
);
565 compat_setup_return(regs
, ka
, frame
->retcode
, frame
, usig
);
570 void compat_setup_restart_syscall(struct pt_regs
*regs
)
572 regs
->regs
[7] = __NR_compat_restart_syscall
;