[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Qemu-devel] [PATCH v3 resend 08/11] linux-user: Add signal handling for
From: |
John Rigby |
Subject: |
[Qemu-devel] [PATCH v3 resend 08/11] linux-user: Add signal handling for AArch64 |
Date: |
Mon, 13 May 2013 00:57:55 -0600 |
From: Andreas Schwab <address@hidden>
This patch adds signal handling for AArch64. The code is based on the
respective source in the Linux kernel.
Signed-off-by: Andreas Schwab <address@hidden>
Signed-off-by: Alexander Graf <address@hidden>
Signed-off-by: John Rigby <address@hidden>
---
Changes in v3:
- Remove unneeded __{put,get}__user error checking
- Fix checkpatch.pl issues
linux-user/arm/target_signal.h | 4 +
linux-user/signal.c | 251 +++++++++++++++++++++++++++++++++++++++++
2 files changed, 255 insertions(+)
diff --git a/linux-user/arm/target_signal.h b/linux-user/arm/target_signal.h
index 2b32813..afc8698 100644
--- a/linux-user/arm/target_signal.h
+++ b/linux-user/arm/target_signal.h
@@ -23,7 +23,11 @@ typedef struct target_sigaltstack {
static inline abi_ulong get_sp_from_cpustate(CPUARMState *state)
{
+#ifdef TARGET_AARCH64
+ return state->sp;
+#else
return state->regs[13];
+#endif
}
#endif /* TARGET_SIGNAL_H */
diff --git a/linux-user/signal.c b/linux-user/signal.c
index 1055507..3f1b91b 100644
--- a/linux-user/signal.c
+++ b/linux-user/signal.c
@@ -1090,6 +1090,257 @@ 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];
+};
+
+/*
+ * 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->sp, &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 * 2; i++) {
+ __put_user(env->vfp.regs[i], &aux->fpsimd.vregs[i]);
+ }
+ __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->sp, &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->sp;
+
+ /*
+ * 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->sp),
+ &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->sp = frame_addr;
+ env->xregs[29] = env->sp + offsetof(struct target_rt_sigframe, fp);
+ env->pc = ka->_sa_handler;
+ env->xregs[30] = env->sp + offsetof(struct target_rt_sigframe, tramp);
+ if (info) {
+ err |= copy_siginfo_to_user(&frame->info, info);
+ 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->sp;
+
+ 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 {
--
1.8.2.2
- [Qemu-devel] [PATCH v3 resend 00/11] AArch64 preparation patch set, John Rigby, 2013/05/13
- [Qemu-devel] [PATCH v3 resend 01/11] ARM: Export cpu_env, John Rigby, 2013/05/13
- [Qemu-devel] [PATCH v3 resend 02/11] ARM: Prepare translation for AArch64 code, John Rigby, 2013/05/13
- [Qemu-devel] [PATCH v3 resend 03/11] ARM: Add AArch64 translation stub, John Rigby, 2013/05/13
- [Qemu-devel] [PATCH v3 resend 04/11] AArch64: Add gdb stub, John Rigby, 2013/05/13
- [Qemu-devel] [PATCH v3 resend 05/11] linux-user: Don't treat aarch64 cpu names specially, John Rigby, 2013/05/13
- [Qemu-devel] [PATCH v3 resend 06/11] linux-user: Add syscall handling for AArch64, John Rigby, 2013/05/13
- [Qemu-devel] [PATCH v3 resend 07/11] linux-user: Fix up AArch64 syscall handlers, John Rigby, 2013/05/13
- [Qemu-devel] [PATCH v3 resend 08/11] linux-user: Add signal handling for AArch64,
John Rigby <=
- [Qemu-devel] [PATCH v3 resend 09/11] linux-user: Add AArch64 support, John Rigby, 2013/05/13
- [Qemu-devel] [PATCH v3 resend 10/11] ARM: Add aarch64 target to configure, John Rigby, 2013/05/13
- [Qemu-devel] [PATCH v3 resend 11/11] linux-user: AArch64 requires at least 3.8.0, John Rigby, 2013/05/13
- Re: [Qemu-devel] [PATCH v3 resend 00/11] AArch64 preparation patch set, Peter Maydell, 2013/05/13