linux-user: Add signal handling for AArch64
This patch adds signal handling for AArch64. The code is based on the respective source in the Linux kernel. Signed-off-by: Andreas Schwab <schwab@suse.de> Signed-off-by: Alexander Graf <agraf@suse.de> Signed-off-by: John Rigby <john.rigby@linaro.org> Signed-off-by: Peter Maydell <peter.maydell@linaro.org> Message-id: 1378235544-22290-17-git-send-email-peter.maydell@linaro.org Message-id: 1368505980-17151-10-git-send-email-john.rigby@linaro.org [PMM: fixed style nits: tabs, long lines; pulled target_signal.h in from a later patch; it fits better here] Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Andreas Schwab
Peter Maydell
parent
09701199f6
commit
1744aea182
|
|
@ -0,0 +1,29 @@
|
|||
#ifndef TARGET_SIGNAL_H
|
||||
#define TARGET_SIGNAL_H
|
||||
|
||||
#include "cpu.h"
|
||||
|
||||
/* this struct defines a stack used during syscall handling */
|
||||
|
||||
typedef struct target_sigaltstack {
|
||||
abi_ulong ss_sp;
|
||||
abi_int ss_flags;
|
||||
abi_ulong ss_size;
|
||||
} target_stack_t;
|
||||
|
||||
|
||||
/*
|
||||
* sigaltstack controls
|
||||
*/
|
||||
#define TARGET_SS_ONSTACK 1
|
||||
#define TARGET_SS_DISABLE 2
|
||||
|
||||
#define TARGET_MINSIGSTKSZ 2048
|
||||
#define TARGET_SIGSTKSZ 8192
|
||||
|
||||
static inline abi_ulong get_sp_from_cpustate(CPUARMState *state)
|
||||
{
|
||||
return state->xregs[31];
|
||||
}
|
||||
|
||||
#endif /* TARGET_SIGNAL_H */
|
||||
|
|
@ -1092,6 +1092,266 @@ badframe:
|
|||
return 0;
|
||||
}
|
||||
|
||||
#elif defined(TARGET_AARCH64)
|
||||
|
||||
struct target_sigcontext {
|
||||
uint64_t fault_address;
|
||||
/* AArch64 registers */
|
||||
uint64_t regs[31];
|
||||
uint64_t sp;
|
||||
uint64_t pc;
|
||||
uint64_t pstate;
|
||||
/* 4K reserved for FP/SIMD state and future expansion */
|
||||
char __reserved[4096] __attribute__((__aligned__(16)));
|
||||
};
|
||||
|
||||
struct target_ucontext {
|
||||
abi_ulong tuc_flags;
|
||||
abi_ulong tuc_link;
|
||||
target_stack_t tuc_stack;
|
||||
target_sigset_t tuc_sigmask;
|
||||
/* glibc uses a 1024-bit sigset_t */
|
||||
char __unused[1024 / 8 - sizeof(target_sigset_t)];
|
||||
/* last for future expansion */
|
||||
struct target_sigcontext tuc_mcontext;
|
||||
};
|
||||
|
||||
/*
|
||||
* Header to be used at the beginning of structures extending the user
|
||||
* context. Such structures must be placed after the rt_sigframe on the stack
|
||||
* and be 16-byte aligned. The last structure must be a dummy one with the
|
||||
* magic and size set to 0.
|
||||
*/
|
||||
struct target_aarch64_ctx {
|
||||
uint32_t magic;
|
||||
uint32_t size;
|
||||
};
|
||||
|
||||
#define TARGET_FPSIMD_MAGIC 0x46508001
|
||||
|
||||
struct target_fpsimd_context {
|
||||
struct target_aarch64_ctx head;
|
||||
uint32_t fpsr;
|
||||
uint32_t fpcr;
|
||||
uint64_t vregs[32 * 2]; /* really uint128_t vregs[32] */
|
||||
};
|
||||
|
||||
/*
|
||||
* Auxiliary context saved in the sigcontext.__reserved array. Not exported to
|
||||
* user space as it will change with the addition of new context. User space
|
||||
* should check the magic/size information.
|
||||
*/
|
||||
struct target_aux_context {
|
||||
struct target_fpsimd_context fpsimd;
|
||||
/* additional context to be added before "end" */
|
||||
struct target_aarch64_ctx end;
|
||||
};
|
||||
|
||||
struct target_rt_sigframe {
|
||||
struct target_siginfo info;
|
||||
struct target_ucontext uc;
|
||||
uint64_t fp;
|
||||
uint64_t lr;
|
||||
uint32_t tramp[2];
|
||||
};
|
||||
|
||||
static int target_setup_sigframe(struct target_rt_sigframe *sf,
|
||||
CPUARMState *env, target_sigset_t *set)
|
||||
{
|
||||
int i;
|
||||
struct target_aux_context *aux =
|
||||
(struct target_aux_context *)sf->uc.tuc_mcontext.__reserved;
|
||||
|
||||
/* set up the stack frame for unwinding */
|
||||
__put_user(env->xregs[29], &sf->fp);
|
||||
__put_user(env->xregs[30], &sf->lr);
|
||||
|
||||
for (i = 0; i < 31; i++) {
|
||||
__put_user(env->xregs[i], &sf->uc.tuc_mcontext.regs[i]);
|
||||
}
|
||||
__put_user(env->xregs[31], &sf->uc.tuc_mcontext.sp);
|
||||
__put_user(env->pc, &sf->uc.tuc_mcontext.pc);
|
||||
__put_user(env->pstate, &sf->uc.tuc_mcontext.pstate);
|
||||
|
||||
__put_user(/*current->thread.fault_address*/ 0,
|
||||
&sf->uc.tuc_mcontext.fault_address);
|
||||
|
||||
for (i = 0; i < TARGET_NSIG_WORDS; i++) {
|
||||
__put_user(set->sig[i], &sf->uc.tuc_sigmask.sig[i]);
|
||||
}
|
||||
|
||||
for (i = 0; i < 32; i++) {
|
||||
#ifdef TARGET_WORDS_BIGENDIAN
|
||||
__put_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2 + 1]);
|
||||
__put_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2]);
|
||||
#else
|
||||
__put_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2]);
|
||||
__put_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2 + 1]);
|
||||
#endif
|
||||
}
|
||||
__put_user(/*env->fpsr*/0, &aux->fpsimd.fpsr);
|
||||
__put_user(/*env->fpcr*/0, &aux->fpsimd.fpcr);
|
||||
__put_user(TARGET_FPSIMD_MAGIC, &aux->fpsimd.head.magic);
|
||||
__put_user(sizeof(struct target_fpsimd_context),
|
||||
&aux->fpsimd.head.size);
|
||||
|
||||
/* set the "end" magic */
|
||||
__put_user(0, &aux->end.magic);
|
||||
__put_user(0, &aux->end.size);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int target_restore_sigframe(CPUARMState *env,
|
||||
struct target_rt_sigframe *sf)
|
||||
{
|
||||
sigset_t set;
|
||||
int i;
|
||||
struct target_aux_context *aux =
|
||||
(struct target_aux_context *)sf->uc.tuc_mcontext.__reserved;
|
||||
uint32_t magic, size;
|
||||
|
||||
target_to_host_sigset(&set, &sf->uc.tuc_sigmask);
|
||||
sigprocmask(SIG_SETMASK, &set, NULL);
|
||||
|
||||
for (i = 0; i < 31; i++) {
|
||||
__get_user(env->xregs[i], &sf->uc.tuc_mcontext.regs[i]);
|
||||
}
|
||||
|
||||
__get_user(env->xregs[31], &sf->uc.tuc_mcontext.sp);
|
||||
__get_user(env->pc, &sf->uc.tuc_mcontext.pc);
|
||||
__get_user(env->pstate, &sf->uc.tuc_mcontext.pstate);
|
||||
|
||||
__get_user(magic, &aux->fpsimd.head.magic);
|
||||
__get_user(size, &aux->fpsimd.head.size);
|
||||
|
||||
if (magic != TARGET_FPSIMD_MAGIC
|
||||
|| size != sizeof(struct target_fpsimd_context)) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
for (i = 0; i < 32 * 2; i++) {
|
||||
__get_user(env->vfp.regs[i], &aux->fpsimd.vregs[i]);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static abi_ulong get_sigframe(struct target_sigaction *ka, CPUARMState *env)
|
||||
{
|
||||
abi_ulong sp;
|
||||
|
||||
sp = env->xregs[31];
|
||||
|
||||
/*
|
||||
* This is the X/Open sanctioned signal stack switching.
|
||||
*/
|
||||
if ((ka->sa_flags & SA_ONSTACK) && !sas_ss_flags(sp)) {
|
||||
sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
|
||||
}
|
||||
|
||||
sp = (sp - sizeof(struct target_rt_sigframe)) & ~15;
|
||||
|
||||
return sp;
|
||||
}
|
||||
|
||||
static void target_setup_frame(int usig, struct target_sigaction *ka,
|
||||
target_siginfo_t *info, target_sigset_t *set,
|
||||
CPUARMState *env)
|
||||
{
|
||||
struct target_rt_sigframe *frame;
|
||||
abi_ulong frame_addr;
|
||||
|
||||
frame_addr = get_sigframe(ka, env);
|
||||
if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
|
||||
goto give_sigsegv;
|
||||
}
|
||||
|
||||
__put_user(0, &frame->uc.tuc_flags);
|
||||
__put_user(0, &frame->uc.tuc_link);
|
||||
|
||||
__put_user(target_sigaltstack_used.ss_sp,
|
||||
&frame->uc.tuc_stack.ss_sp);
|
||||
__put_user(sas_ss_flags(env->xregs[31]),
|
||||
&frame->uc.tuc_stack.ss_flags);
|
||||
__put_user(target_sigaltstack_used.ss_size,
|
||||
&frame->uc.tuc_stack.ss_size);
|
||||
target_setup_sigframe(frame, env, set);
|
||||
/* mov x8,#__NR_rt_sigreturn; svc #0 */
|
||||
__put_user(0xd2801168, &frame->tramp[0]);
|
||||
__put_user(0xd4000001, &frame->tramp[1]);
|
||||
env->xregs[0] = usig;
|
||||
env->xregs[31] = frame_addr;
|
||||
env->xregs[29] = env->xregs[31] + offsetof(struct target_rt_sigframe, fp);
|
||||
env->pc = ka->_sa_handler;
|
||||
env->xregs[30] = env->xregs[31] +
|
||||
offsetof(struct target_rt_sigframe, tramp);
|
||||
if (info) {
|
||||
if (copy_siginfo_to_user(&frame->info, info)) {
|
||||
goto give_sigsegv;
|
||||
}
|
||||
env->xregs[1] = frame_addr + offsetof(struct target_rt_sigframe, info);
|
||||
env->xregs[2] = frame_addr + offsetof(struct target_rt_sigframe, uc);
|
||||
}
|
||||
|
||||
unlock_user_struct(frame, frame_addr, 1);
|
||||
return;
|
||||
|
||||
give_sigsegv:
|
||||
unlock_user_struct(frame, frame_addr, 1);
|
||||
force_sig(TARGET_SIGSEGV);
|
||||
}
|
||||
|
||||
static void setup_rt_frame(int sig, struct target_sigaction *ka,
|
||||
target_siginfo_t *info, target_sigset_t *set,
|
||||
CPUARMState *env)
|
||||
{
|
||||
target_setup_frame(sig, ka, info, set, env);
|
||||
}
|
||||
|
||||
static void setup_frame(int sig, struct target_sigaction *ka,
|
||||
target_sigset_t *set, CPUARMState *env)
|
||||
{
|
||||
target_setup_frame(sig, ka, 0, set, env);
|
||||
}
|
||||
|
||||
long do_rt_sigreturn(CPUARMState *env)
|
||||
{
|
||||
struct target_rt_sigframe *frame;
|
||||
abi_ulong frame_addr = env->xregs[31];
|
||||
|
||||
if (frame_addr & 15) {
|
||||
goto badframe;
|
||||
}
|
||||
|
||||
if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
|
||||
goto badframe;
|
||||
}
|
||||
|
||||
if (target_restore_sigframe(env, frame)) {
|
||||
goto badframe;
|
||||
}
|
||||
|
||||
if (do_sigaltstack(frame_addr +
|
||||
offsetof(struct target_rt_sigframe, uc.tuc_stack),
|
||||
0, get_sp_from_cpustate(env)) == -EFAULT) {
|
||||
goto badframe;
|
||||
}
|
||||
|
||||
unlock_user_struct(frame, frame_addr, 0);
|
||||
return env->xregs[0];
|
||||
|
||||
badframe:
|
||||
unlock_user_struct(frame, frame_addr, 0);
|
||||
force_sig(TARGET_SIGSEGV);
|
||||
return 0;
|
||||
}
|
||||
|
||||
long do_sigreturn(CPUARMState *env)
|
||||
{
|
||||
return do_rt_sigreturn(env);
|
||||
}
|
||||
|
||||
#elif defined(TARGET_ARM)
|
||||
|
||||
struct target_sigcontext {
|
||||
|
|
|
|||
Loading…
Reference in New Issue