Laurent Vivier <laur...@vivier.eu> writes: > No code change, only move code from signal.c to > aarch64/signal.c, except adding includes and > exporting setup_frame() and setup_rt_frame(). > > Signed-off-by: Laurent Vivier <laur...@vivier.eu>
Reviewed-by: Alex Bennée <alex.ben...@linaro.org> > --- > linux-user/aarch64/signal.c | 561 > +++++++++++++++++++++++++++++++++++++ > linux-user/aarch64/target_signal.h | 5 + > linux-user/signal.c | 560 +----------------------------------- > 3 files changed, 567 insertions(+), 559 deletions(-) > > diff --git a/linux-user/aarch64/signal.c b/linux-user/aarch64/signal.c > index 02ca338b6c..c472f86bcb 100644 > --- a/linux-user/aarch64/signal.c > +++ b/linux-user/aarch64/signal.c > @@ -16,3 +16,564 @@ > * You should have received a copy of the GNU General Public License > * along with this program; if not, see <http://www.gnu.org/licenses/>. > */ > +#include "qemu/osdep.h" > +#include "qemu.h" > +#include "target_signal.h" > +#include "signal-common.h" > +#include "linux-user/trace.h" > + > +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] */ > +}; > + > +#define TARGET_EXTRA_MAGIC 0x45585401 > + > +struct target_extra_context { > + struct target_aarch64_ctx head; > + uint64_t datap; /* 16-byte aligned pointer to extra space cast to __u64 > */ > + uint32_t size; /* size in bytes of the extra space */ > + uint32_t reserved[3]; > +}; > + > +#define TARGET_SVE_MAGIC 0x53564501 > + > +struct target_sve_context { > + struct target_aarch64_ctx head; > + uint16_t vl; > + uint16_t reserved[3]; > + /* The actual SVE data immediately follows. It is layed out > + * according to TARGET_SVE_SIG_{Z,P}REG_OFFSET, based off of > + * the original struct pointer. > + */ > +}; > + > +#define TARGET_SVE_VQ_BYTES 16 > + > +#define TARGET_SVE_SIG_ZREG_SIZE(VQ) ((VQ) * TARGET_SVE_VQ_BYTES) > +#define TARGET_SVE_SIG_PREG_SIZE(VQ) ((VQ) * (TARGET_SVE_VQ_BYTES / 8)) > + > +#define TARGET_SVE_SIG_REGS_OFFSET \ > + QEMU_ALIGN_UP(sizeof(struct target_sve_context), TARGET_SVE_VQ_BYTES) > +#define TARGET_SVE_SIG_ZREG_OFFSET(VQ, N) \ > + (TARGET_SVE_SIG_REGS_OFFSET + TARGET_SVE_SIG_ZREG_SIZE(VQ) * (N)) > +#define TARGET_SVE_SIG_PREG_OFFSET(VQ, N) \ > + (TARGET_SVE_SIG_ZREG_OFFSET(VQ, 32) + TARGET_SVE_SIG_PREG_SIZE(VQ) * (N)) > +#define TARGET_SVE_SIG_FFR_OFFSET(VQ) \ > + (TARGET_SVE_SIG_PREG_OFFSET(VQ, 16)) > +#define TARGET_SVE_SIG_CONTEXT_SIZE(VQ) \ > + (TARGET_SVE_SIG_PREG_OFFSET(VQ, 17)) > + > +struct target_rt_sigframe { > + struct target_siginfo info; > + struct target_ucontext uc; > +}; > + > +struct target_rt_frame_record { > + uint64_t fp; > + uint64_t lr; > + uint32_t tramp[2]; > +}; > + > +static void target_setup_general_frame(struct target_rt_sigframe *sf, > + CPUARMState *env, target_sigset_t > *set) > +{ > + int i; > + > + __put_user(0, &sf->uc.tuc_flags); > + __put_user(0, &sf->uc.tuc_link); > + > + __put_user(target_sigaltstack_used.ss_sp, &sf->uc.tuc_stack.ss_sp); > + __put_user(sas_ss_flags(env->xregs[31]), &sf->uc.tuc_stack.ss_flags); > + __put_user(target_sigaltstack_used.ss_size, &sf->uc.tuc_stack.ss_size); > + > + 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(pstate_read(env), &sf->uc.tuc_mcontext.pstate); > + > + __put_user(env->exception.vaddress, &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]); > + } > +} > + > +static void target_setup_fpsimd_record(struct target_fpsimd_context *fpsimd, > + CPUARMState *env) > +{ > + int i; > + > + __put_user(TARGET_FPSIMD_MAGIC, &fpsimd->head.magic); > + __put_user(sizeof(struct target_fpsimd_context), &fpsimd->head.size); > + __put_user(vfp_get_fpsr(env), &fpsimd->fpsr); > + __put_user(vfp_get_fpcr(env), &fpsimd->fpcr); > + > + for (i = 0; i < 32; i++) { > + uint64_t *q = aa64_vfp_qreg(env, i); > +#ifdef TARGET_WORDS_BIGENDIAN > + __put_user(q[0], &fpsimd->vregs[i * 2 + 1]); > + __put_user(q[1], &fpsimd->vregs[i * 2]); > +#else > + __put_user(q[0], &fpsimd->vregs[i * 2]); > + __put_user(q[1], &fpsimd->vregs[i * 2 + 1]); > +#endif > + } > +} > + > +static void target_setup_extra_record(struct target_extra_context *extra, > + uint64_t datap, uint32_t extra_size) > +{ > + __put_user(TARGET_EXTRA_MAGIC, &extra->head.magic); > + __put_user(sizeof(struct target_extra_context), &extra->head.size); > + __put_user(datap, &extra->datap); > + __put_user(extra_size, &extra->size); > +} > + > +static void target_setup_end_record(struct target_aarch64_ctx *end) > +{ > + __put_user(0, &end->magic); > + __put_user(0, &end->size); > +} > + > +static void target_setup_sve_record(struct target_sve_context *sve, > + CPUARMState *env, int vq, int size) > +{ > + int i, j; > + > + __put_user(TARGET_SVE_MAGIC, &sve->head.magic); > + __put_user(size, &sve->head.size); > + __put_user(vq * TARGET_SVE_VQ_BYTES, &sve->vl); > + > + /* Note that SVE regs are stored as a byte stream, with each byte element > + * at a subsequent address. This corresponds to a little-endian store > + * of our 64-bit hunks. > + */ > + for (i = 0; i < 32; ++i) { > + uint64_t *z = (void *)sve + TARGET_SVE_SIG_ZREG_OFFSET(vq, i); > + for (j = 0; j < vq * 2; ++j) { > + __put_user_e(env->vfp.zregs[i].d[j], z + j, le); > + } > + } > + for (i = 0; i <= 16; ++i) { > + uint16_t *p = (void *)sve + TARGET_SVE_SIG_PREG_OFFSET(vq, i); > + for (j = 0; j < vq; ++j) { > + uint64_t r = env->vfp.pregs[i].p[j >> 2]; > + __put_user_e(r >> ((j & 3) * 16), p + j, le); > + } > + } > +} > + > +static void target_restore_general_frame(CPUARMState *env, > + struct target_rt_sigframe *sf) > +{ > + sigset_t set; > + uint64_t pstate; > + int i; > + > + target_to_host_sigset(&set, &sf->uc.tuc_sigmask); > + set_sigmask(&set); > + > + 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(pstate, &sf->uc.tuc_mcontext.pstate); > + pstate_write(env, pstate); > +} > + > +static void target_restore_fpsimd_record(CPUARMState *env, > + struct target_fpsimd_context > *fpsimd) > +{ > + uint32_t fpsr, fpcr; > + int i; > + > + __get_user(fpsr, &fpsimd->fpsr); > + vfp_set_fpsr(env, fpsr); > + __get_user(fpcr, &fpsimd->fpcr); > + vfp_set_fpcr(env, fpcr); > + > + for (i = 0; i < 32; i++) { > + uint64_t *q = aa64_vfp_qreg(env, i); > +#ifdef TARGET_WORDS_BIGENDIAN > + __get_user(q[0], &fpsimd->vregs[i * 2 + 1]); > + __get_user(q[1], &fpsimd->vregs[i * 2]); > +#else > + __get_user(q[0], &fpsimd->vregs[i * 2]); > + __get_user(q[1], &fpsimd->vregs[i * 2 + 1]); > +#endif > + } > +} > + > +static void target_restore_sve_record(CPUARMState *env, > + struct target_sve_context *sve, int vq) > +{ > + int i, j; > + > + /* Note that SVE regs are stored as a byte stream, with each byte element > + * at a subsequent address. This corresponds to a little-endian load > + * of our 64-bit hunks. > + */ > + for (i = 0; i < 32; ++i) { > + uint64_t *z = (void *)sve + TARGET_SVE_SIG_ZREG_OFFSET(vq, i); > + for (j = 0; j < vq * 2; ++j) { > + __get_user_e(env->vfp.zregs[i].d[j], z + j, le); > + } > + } > + for (i = 0; i <= 16; ++i) { > + uint16_t *p = (void *)sve + TARGET_SVE_SIG_PREG_OFFSET(vq, i); > + for (j = 0; j < vq; ++j) { > + uint16_t r; > + __get_user_e(r, p + j, le); > + if (j & 3) { > + env->vfp.pregs[i].p[j >> 2] |= (uint64_t)r << ((j & 3) * 16); > + } else { > + env->vfp.pregs[i].p[j >> 2] = r; > + } > + } > + } > +} > + > +static int target_restore_sigframe(CPUARMState *env, > + struct target_rt_sigframe *sf) > +{ > + struct target_aarch64_ctx *ctx, *extra = NULL; > + struct target_fpsimd_context *fpsimd = NULL; > + struct target_sve_context *sve = NULL; > + uint64_t extra_datap = 0; > + bool used_extra = false; > + bool err = false; > + int vq = 0, sve_size = 0; > + > + target_restore_general_frame(env, sf); > + > + ctx = (struct target_aarch64_ctx *)sf->uc.tuc_mcontext.__reserved; > + while (ctx) { > + uint32_t magic, size, extra_size; > + > + __get_user(magic, &ctx->magic); > + __get_user(size, &ctx->size); > + switch (magic) { > + case 0: > + if (size != 0) { > + err = true; > + goto exit; > + } > + if (used_extra) { > + ctx = NULL; > + } else { > + ctx = extra; > + used_extra = true; > + } > + continue; > + > + case TARGET_FPSIMD_MAGIC: > + if (fpsimd || size != sizeof(struct target_fpsimd_context)) { > + err = true; > + goto exit; > + } > + fpsimd = (struct target_fpsimd_context *)ctx; > + break; > + > + case TARGET_SVE_MAGIC: > + if (arm_feature(env, ARM_FEATURE_SVE)) { > + vq = (env->vfp.zcr_el[1] & 0xf) + 1; > + sve_size = QEMU_ALIGN_UP(TARGET_SVE_SIG_CONTEXT_SIZE(vq), > 16); > + if (!sve && size == sve_size) { > + sve = (struct target_sve_context *)ctx; > + break; > + } > + } > + err = true; > + goto exit; > + > + case TARGET_EXTRA_MAGIC: > + if (extra || size != sizeof(struct target_extra_context)) { > + err = true; > + goto exit; > + } > + __get_user(extra_datap, > + &((struct target_extra_context *)ctx)->datap); > + __get_user(extra_size, > + &((struct target_extra_context *)ctx)->size); > + extra = lock_user(VERIFY_READ, extra_datap, extra_size, 0); > + break; > + > + default: > + /* Unknown record -- we certainly didn't generate it. > + * Did we in fact get out of sync? > + */ > + err = true; > + goto exit; > + } > + ctx = (void *)ctx + size; > + } > + > + /* Require FPSIMD always. */ > + if (fpsimd) { > + target_restore_fpsimd_record(env, fpsimd); > + } else { > + err = true; > + } > + > + /* SVE data, if present, overwrites FPSIMD data. */ > + if (sve) { > + target_restore_sve_record(env, sve, vq); > + } > + > + exit: > + unlock_user(extra, extra_datap, 0); > + return err; > +} > + > +static abi_ulong get_sigframe(struct target_sigaction *ka, > + CPUARMState *env, int size) > +{ > + abi_ulong sp; > + > + sp = env->xregs[31]; > + > + /* > + * This is the X/Open sanctioned signal stack switching. > + */ > + if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp)) { > + sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; > + } > + > + sp = (sp - size) & ~15; > + > + return sp; > +} > + > +typedef struct { > + int total_size; > + int extra_base; > + int extra_size; > + int std_end_ofs; > + int extra_ofs; > + int extra_end_ofs; > +} target_sigframe_layout; > + > +static int alloc_sigframe_space(int this_size, target_sigframe_layout *l) > +{ > + /* Make sure there will always be space for the end marker. */ > + const int std_size = sizeof(struct target_rt_sigframe) > + - sizeof(struct target_aarch64_ctx); > + int this_loc = l->total_size; > + > + if (l->extra_base) { > + /* Once we have begun an extra space, all allocations go there. */ > + l->extra_size += this_size; > + } else if (this_size + this_loc > std_size) { > + /* This allocation does not fit in the standard space. */ > + /* Allocate the extra record. */ > + l->extra_ofs = this_loc; > + l->total_size += sizeof(struct target_extra_context); > + > + /* Allocate the standard end record. */ > + l->std_end_ofs = l->total_size; > + l->total_size += sizeof(struct target_aarch64_ctx); > + > + /* Allocate the requested record. */ > + l->extra_base = this_loc = l->total_size; > + l->extra_size = this_size; > + } > + l->total_size += this_size; > + > + return this_loc; > +} > + > +static void target_setup_frame(int usig, struct target_sigaction *ka, > + target_siginfo_t *info, target_sigset_t *set, > + CPUARMState *env) > +{ > + target_sigframe_layout layout = { > + /* Begin with the size pointing to the reserved space. */ > + .total_size = offsetof(struct target_rt_sigframe, > + uc.tuc_mcontext.__reserved), > + }; > + int fpsimd_ofs, fr_ofs, sve_ofs = 0, vq = 0, sve_size = 0; > + struct target_rt_sigframe *frame; > + struct target_rt_frame_record *fr; > + abi_ulong frame_addr, return_addr; > + > + /* FPSIMD record is always in the standard space. */ > + fpsimd_ofs = alloc_sigframe_space(sizeof(struct target_fpsimd_context), > + &layout); > + > + /* SVE state needs saving only if it exists. */ > + if (arm_feature(env, ARM_FEATURE_SVE)) { > + vq = (env->vfp.zcr_el[1] & 0xf) + 1; > + sve_size = QEMU_ALIGN_UP(TARGET_SVE_SIG_CONTEXT_SIZE(vq), 16); > + sve_ofs = alloc_sigframe_space(sve_size, &layout); > + } > + > + if (layout.extra_ofs) { > + /* Reserve space for the extra end marker. The standard end marker > + * will have been allocated when we allocated the extra record. > + */ > + layout.extra_end_ofs > + = alloc_sigframe_space(sizeof(struct target_aarch64_ctx), > &layout); > + } else { > + /* Reserve space for the standard end marker. > + * Do not use alloc_sigframe_space because we cheat > + * std_size therein to reserve space for this. > + */ > + layout.std_end_ofs = layout.total_size; > + layout.total_size += sizeof(struct target_aarch64_ctx); > + } > + > + /* Reserve space for the return code. On a real system this would > + * be within the VDSO. So, despite the name this is not a "real" > + * record within the frame. > + */ > + fr_ofs = layout.total_size; > + layout.total_size += sizeof(struct target_rt_frame_record); > + > + frame_addr = get_sigframe(ka, env, layout.total_size); > + trace_user_setup_frame(env, frame_addr); > + if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { > + goto give_sigsegv; > + } > + > + target_setup_general_frame(frame, env, set); > + target_setup_fpsimd_record((void *)frame + fpsimd_ofs, env); > + target_setup_end_record((void *)frame + layout.std_end_ofs); > + if (layout.extra_ofs) { > + target_setup_extra_record((void *)frame + layout.extra_ofs, > + frame_addr + layout.extra_base, > + layout.extra_size); > + target_setup_end_record((void *)frame + layout.extra_end_ofs); > + } > + if (sve_ofs) { > + target_setup_sve_record((void *)frame + sve_ofs, env, vq, sve_size); > + } > + > + /* Set up the stack frame for unwinding. */ > + fr = (void *)frame + fr_ofs; > + __put_user(env->xregs[29], &fr->fp); > + __put_user(env->xregs[30], &fr->lr); > + > + if (ka->sa_flags & TARGET_SA_RESTORER) { > + return_addr = ka->sa_restorer; > + } else { > + /* > + * mov x8,#__NR_rt_sigreturn; svc #0 > + * Since these are instructions they need to be put as little-endian > + * regardless of target default or current CPU endianness. > + */ > + __put_user_e(0xd2801168, &fr->tramp[0], le); > + __put_user_e(0xd4000001, &fr->tramp[1], le); > + return_addr = frame_addr + fr_ofs > + + offsetof(struct target_rt_frame_record, tramp); > + } > + env->xregs[0] = usig; > + env->xregs[31] = frame_addr; > + env->xregs[29] = frame_addr + fr_ofs; > + env->pc = ka->_sa_handler; > + env->xregs[30] = return_addr; > + if (info) { > + tswap_siginfo(&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_sigsegv(usig); > +} > + > +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); > +} > + > +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 = NULL; > + abi_ulong frame_addr = env->xregs[31]; > + > + trace_user_do_rt_sigreturn(env, frame_addr); > + 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 -TARGET_QEMU_ESIGRETURN; > + > + badframe: > + unlock_user_struct(frame, frame_addr, 0); > + force_sig(TARGET_SIGSEGV); > + return -TARGET_QEMU_ESIGRETURN; > +} > + > +long do_sigreturn(CPUARMState *env) > +{ > + return do_rt_sigreturn(env); > +} > diff --git a/linux-user/aarch64/target_signal.h > b/linux-user/aarch64/target_signal.h > index e66367cac1..af1f1320e2 100644 > --- a/linux-user/aarch64/target_signal.h > +++ b/linux-user/aarch64/target_signal.h > @@ -26,4 +26,9 @@ static inline abi_ulong get_sp_from_cpustate(CPUARMState > *state) > return state->xregs[31]; > } > > +void setup_frame(int sig, struct target_sigaction *ka, > + target_sigset_t *set, CPUARMState *env); > +void setup_rt_frame(int sig, struct target_sigaction *ka, > + target_siginfo_t *info, target_sigset_t *set, > + CPUARMState *env); > #endif /* AARCH64_TARGET_SIGNAL_H */ > diff --git a/linux-user/signal.c b/linux-user/signal.c > index 435cadbe96..2b05d7951b 100644 > --- a/linux-user/signal.c > +++ b/linux-user/signal.c > @@ -1383,565 +1383,7 @@ badframe: > return -TARGET_QEMU_ESIGRETURN; > } > > -#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] */ > -}; > - > -#define TARGET_EXTRA_MAGIC 0x45585401 > - > -struct target_extra_context { > - struct target_aarch64_ctx head; > - uint64_t datap; /* 16-byte aligned pointer to extra space cast to __u64 > */ > - uint32_t size; /* size in bytes of the extra space */ > - uint32_t reserved[3]; > -}; > - > -#define TARGET_SVE_MAGIC 0x53564501 > - > -struct target_sve_context { > - struct target_aarch64_ctx head; > - uint16_t vl; > - uint16_t reserved[3]; > - /* The actual SVE data immediately follows. It is layed out > - * according to TARGET_SVE_SIG_{Z,P}REG_OFFSET, based off of > - * the original struct pointer. > - */ > -}; > - > -#define TARGET_SVE_VQ_BYTES 16 > - > -#define TARGET_SVE_SIG_ZREG_SIZE(VQ) ((VQ) * TARGET_SVE_VQ_BYTES) > -#define TARGET_SVE_SIG_PREG_SIZE(VQ) ((VQ) * (TARGET_SVE_VQ_BYTES / 8)) > - > -#define TARGET_SVE_SIG_REGS_OFFSET \ > - QEMU_ALIGN_UP(sizeof(struct target_sve_context), TARGET_SVE_VQ_BYTES) > -#define TARGET_SVE_SIG_ZREG_OFFSET(VQ, N) \ > - (TARGET_SVE_SIG_REGS_OFFSET + TARGET_SVE_SIG_ZREG_SIZE(VQ) * (N)) > -#define TARGET_SVE_SIG_PREG_OFFSET(VQ, N) \ > - (TARGET_SVE_SIG_ZREG_OFFSET(VQ, 32) + TARGET_SVE_SIG_PREG_SIZE(VQ) * (N)) > -#define TARGET_SVE_SIG_FFR_OFFSET(VQ) \ > - (TARGET_SVE_SIG_PREG_OFFSET(VQ, 16)) > -#define TARGET_SVE_SIG_CONTEXT_SIZE(VQ) \ > - (TARGET_SVE_SIG_PREG_OFFSET(VQ, 17)) > - > -struct target_rt_sigframe { > - struct target_siginfo info; > - struct target_ucontext uc; > -}; > - > -struct target_rt_frame_record { > - uint64_t fp; > - uint64_t lr; > - uint32_t tramp[2]; > -}; > - > -static void target_setup_general_frame(struct target_rt_sigframe *sf, > - CPUARMState *env, target_sigset_t > *set) > -{ > - int i; > - > - __put_user(0, &sf->uc.tuc_flags); > - __put_user(0, &sf->uc.tuc_link); > - > - __put_user(target_sigaltstack_used.ss_sp, &sf->uc.tuc_stack.ss_sp); > - __put_user(sas_ss_flags(env->xregs[31]), &sf->uc.tuc_stack.ss_flags); > - __put_user(target_sigaltstack_used.ss_size, &sf->uc.tuc_stack.ss_size); > - > - 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(pstate_read(env), &sf->uc.tuc_mcontext.pstate); > - > - __put_user(env->exception.vaddress, &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]); > - } > -} > - > -static void target_setup_fpsimd_record(struct target_fpsimd_context *fpsimd, > - CPUARMState *env) > -{ > - int i; > - > - __put_user(TARGET_FPSIMD_MAGIC, &fpsimd->head.magic); > - __put_user(sizeof(struct target_fpsimd_context), &fpsimd->head.size); > - __put_user(vfp_get_fpsr(env), &fpsimd->fpsr); > - __put_user(vfp_get_fpcr(env), &fpsimd->fpcr); > - > - for (i = 0; i < 32; i++) { > - uint64_t *q = aa64_vfp_qreg(env, i); > -#ifdef TARGET_WORDS_BIGENDIAN > - __put_user(q[0], &fpsimd->vregs[i * 2 + 1]); > - __put_user(q[1], &fpsimd->vregs[i * 2]); > -#else > - __put_user(q[0], &fpsimd->vregs[i * 2]); > - __put_user(q[1], &fpsimd->vregs[i * 2 + 1]); > -#endif > - } > -} > - > -static void target_setup_extra_record(struct target_extra_context *extra, > - uint64_t datap, uint32_t extra_size) > -{ > - __put_user(TARGET_EXTRA_MAGIC, &extra->head.magic); > - __put_user(sizeof(struct target_extra_context), &extra->head.size); > - __put_user(datap, &extra->datap); > - __put_user(extra_size, &extra->size); > -} > - > -static void target_setup_end_record(struct target_aarch64_ctx *end) > -{ > - __put_user(0, &end->magic); > - __put_user(0, &end->size); > -} > - > -static void target_setup_sve_record(struct target_sve_context *sve, > - CPUARMState *env, int vq, int size) > -{ > - int i, j; > - > - __put_user(TARGET_SVE_MAGIC, &sve->head.magic); > - __put_user(size, &sve->head.size); > - __put_user(vq * TARGET_SVE_VQ_BYTES, &sve->vl); > - > - /* Note that SVE regs are stored as a byte stream, with each byte element > - * at a subsequent address. This corresponds to a little-endian store > - * of our 64-bit hunks. > - */ > - for (i = 0; i < 32; ++i) { > - uint64_t *z = (void *)sve + TARGET_SVE_SIG_ZREG_OFFSET(vq, i); > - for (j = 0; j < vq * 2; ++j) { > - __put_user_e(env->vfp.zregs[i].d[j], z + j, le); > - } > - } > - for (i = 0; i <= 16; ++i) { > - uint16_t *p = (void *)sve + TARGET_SVE_SIG_PREG_OFFSET(vq, i); > - for (j = 0; j < vq; ++j) { > - uint64_t r = env->vfp.pregs[i].p[j >> 2]; > - __put_user_e(r >> ((j & 3) * 16), p + j, le); > - } > - } > -} > - > -static void target_restore_general_frame(CPUARMState *env, > - struct target_rt_sigframe *sf) > -{ > - sigset_t set; > - uint64_t pstate; > - int i; > - > - target_to_host_sigset(&set, &sf->uc.tuc_sigmask); > - set_sigmask(&set); > - > - 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(pstate, &sf->uc.tuc_mcontext.pstate); > - pstate_write(env, pstate); > -} > - > -static void target_restore_fpsimd_record(CPUARMState *env, > - struct target_fpsimd_context > *fpsimd) > -{ > - uint32_t fpsr, fpcr; > - int i; > - > - __get_user(fpsr, &fpsimd->fpsr); > - vfp_set_fpsr(env, fpsr); > - __get_user(fpcr, &fpsimd->fpcr); > - vfp_set_fpcr(env, fpcr); > - > - for (i = 0; i < 32; i++) { > - uint64_t *q = aa64_vfp_qreg(env, i); > -#ifdef TARGET_WORDS_BIGENDIAN > - __get_user(q[0], &fpsimd->vregs[i * 2 + 1]); > - __get_user(q[1], &fpsimd->vregs[i * 2]); > -#else > - __get_user(q[0], &fpsimd->vregs[i * 2]); > - __get_user(q[1], &fpsimd->vregs[i * 2 + 1]); > -#endif > - } > -} > - > -static void target_restore_sve_record(CPUARMState *env, > - struct target_sve_context *sve, int vq) > -{ > - int i, j; > - > - /* Note that SVE regs are stored as a byte stream, with each byte element > - * at a subsequent address. This corresponds to a little-endian load > - * of our 64-bit hunks. > - */ > - for (i = 0; i < 32; ++i) { > - uint64_t *z = (void *)sve + TARGET_SVE_SIG_ZREG_OFFSET(vq, i); > - for (j = 0; j < vq * 2; ++j) { > - __get_user_e(env->vfp.zregs[i].d[j], z + j, le); > - } > - } > - for (i = 0; i <= 16; ++i) { > - uint16_t *p = (void *)sve + TARGET_SVE_SIG_PREG_OFFSET(vq, i); > - for (j = 0; j < vq; ++j) { > - uint16_t r; > - __get_user_e(r, p + j, le); > - if (j & 3) { > - env->vfp.pregs[i].p[j >> 2] |= (uint64_t)r << ((j & 3) * 16); > - } else { > - env->vfp.pregs[i].p[j >> 2] = r; > - } > - } > - } > -} > - > -static int target_restore_sigframe(CPUARMState *env, > - struct target_rt_sigframe *sf) > -{ > - struct target_aarch64_ctx *ctx, *extra = NULL; > - struct target_fpsimd_context *fpsimd = NULL; > - struct target_sve_context *sve = NULL; > - uint64_t extra_datap = 0; > - bool used_extra = false; > - bool err = false; > - int vq = 0, sve_size = 0; > - > - target_restore_general_frame(env, sf); > - > - ctx = (struct target_aarch64_ctx *)sf->uc.tuc_mcontext.__reserved; > - while (ctx) { > - uint32_t magic, size, extra_size; > - > - __get_user(magic, &ctx->magic); > - __get_user(size, &ctx->size); > - switch (magic) { > - case 0: > - if (size != 0) { > - err = true; > - goto exit; > - } > - if (used_extra) { > - ctx = NULL; > - } else { > - ctx = extra; > - used_extra = true; > - } > - continue; > - > - case TARGET_FPSIMD_MAGIC: > - if (fpsimd || size != sizeof(struct target_fpsimd_context)) { > - err = true; > - goto exit; > - } > - fpsimd = (struct target_fpsimd_context *)ctx; > - break; > - > - case TARGET_SVE_MAGIC: > - if (arm_feature(env, ARM_FEATURE_SVE)) { > - vq = (env->vfp.zcr_el[1] & 0xf) + 1; > - sve_size = QEMU_ALIGN_UP(TARGET_SVE_SIG_CONTEXT_SIZE(vq), > 16); > - if (!sve && size == sve_size) { > - sve = (struct target_sve_context *)ctx; > - break; > - } > - } > - err = true; > - goto exit; > - > - case TARGET_EXTRA_MAGIC: > - if (extra || size != sizeof(struct target_extra_context)) { > - err = true; > - goto exit; > - } > - __get_user(extra_datap, > - &((struct target_extra_context *)ctx)->datap); > - __get_user(extra_size, > - &((struct target_extra_context *)ctx)->size); > - extra = lock_user(VERIFY_READ, extra_datap, extra_size, 0); > - break; > - > - default: > - /* Unknown record -- we certainly didn't generate it. > - * Did we in fact get out of sync? > - */ > - err = true; > - goto exit; > - } > - ctx = (void *)ctx + size; > - } > - > - /* Require FPSIMD always. */ > - if (fpsimd) { > - target_restore_fpsimd_record(env, fpsimd); > - } else { > - err = true; > - } > - > - /* SVE data, if present, overwrites FPSIMD data. */ > - if (sve) { > - target_restore_sve_record(env, sve, vq); > - } > - > - exit: > - unlock_user(extra, extra_datap, 0); > - return err; > -} > - > -static abi_ulong get_sigframe(struct target_sigaction *ka, > - CPUARMState *env, int size) > -{ > - abi_ulong sp; > - > - sp = env->xregs[31]; > - > - /* > - * This is the X/Open sanctioned signal stack switching. > - */ > - if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp)) { > - sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size; > - } > - > - sp = (sp - size) & ~15; > - > - return sp; > -} > - > -typedef struct { > - int total_size; > - int extra_base; > - int extra_size; > - int std_end_ofs; > - int extra_ofs; > - int extra_end_ofs; > -} target_sigframe_layout; > - > -static int alloc_sigframe_space(int this_size, target_sigframe_layout *l) > -{ > - /* Make sure there will always be space for the end marker. */ > - const int std_size = sizeof(struct target_rt_sigframe) > - - sizeof(struct target_aarch64_ctx); > - int this_loc = l->total_size; > - > - if (l->extra_base) { > - /* Once we have begun an extra space, all allocations go there. */ > - l->extra_size += this_size; > - } else if (this_size + this_loc > std_size) { > - /* This allocation does not fit in the standard space. */ > - /* Allocate the extra record. */ > - l->extra_ofs = this_loc; > - l->total_size += sizeof(struct target_extra_context); > - > - /* Allocate the standard end record. */ > - l->std_end_ofs = l->total_size; > - l->total_size += sizeof(struct target_aarch64_ctx); > - > - /* Allocate the requested record. */ > - l->extra_base = this_loc = l->total_size; > - l->extra_size = this_size; > - } > - l->total_size += this_size; > - > - return this_loc; > -} > - > -static void target_setup_frame(int usig, struct target_sigaction *ka, > - target_siginfo_t *info, target_sigset_t *set, > - CPUARMState *env) > -{ > - target_sigframe_layout layout = { > - /* Begin with the size pointing to the reserved space. */ > - .total_size = offsetof(struct target_rt_sigframe, > - uc.tuc_mcontext.__reserved), > - }; > - int fpsimd_ofs, fr_ofs, sve_ofs = 0, vq = 0, sve_size = 0; > - struct target_rt_sigframe *frame; > - struct target_rt_frame_record *fr; > - abi_ulong frame_addr, return_addr; > - > - /* FPSIMD record is always in the standard space. */ > - fpsimd_ofs = alloc_sigframe_space(sizeof(struct target_fpsimd_context), > - &layout); > - > - /* SVE state needs saving only if it exists. */ > - if (arm_feature(env, ARM_FEATURE_SVE)) { > - vq = (env->vfp.zcr_el[1] & 0xf) + 1; > - sve_size = QEMU_ALIGN_UP(TARGET_SVE_SIG_CONTEXT_SIZE(vq), 16); > - sve_ofs = alloc_sigframe_space(sve_size, &layout); > - } > - > - if (layout.extra_ofs) { > - /* Reserve space for the extra end marker. The standard end marker > - * will have been allocated when we allocated the extra record. > - */ > - layout.extra_end_ofs > - = alloc_sigframe_space(sizeof(struct target_aarch64_ctx), > &layout); > - } else { > - /* Reserve space for the standard end marker. > - * Do not use alloc_sigframe_space because we cheat > - * std_size therein to reserve space for this. > - */ > - layout.std_end_ofs = layout.total_size; > - layout.total_size += sizeof(struct target_aarch64_ctx); > - } > - > - /* Reserve space for the return code. On a real system this would > - * be within the VDSO. So, despite the name this is not a "real" > - * record within the frame. > - */ > - fr_ofs = layout.total_size; > - layout.total_size += sizeof(struct target_rt_frame_record); > - > - frame_addr = get_sigframe(ka, env, layout.total_size); > - trace_user_setup_frame(env, frame_addr); > - if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { > - goto give_sigsegv; > - } > - > - target_setup_general_frame(frame, env, set); > - target_setup_fpsimd_record((void *)frame + fpsimd_ofs, env); > - target_setup_end_record((void *)frame + layout.std_end_ofs); > - if (layout.extra_ofs) { > - target_setup_extra_record((void *)frame + layout.extra_ofs, > - frame_addr + layout.extra_base, > - layout.extra_size); > - target_setup_end_record((void *)frame + layout.extra_end_ofs); > - } > - if (sve_ofs) { > - target_setup_sve_record((void *)frame + sve_ofs, env, vq, sve_size); > - } > - > - /* Set up the stack frame for unwinding. */ > - fr = (void *)frame + fr_ofs; > - __put_user(env->xregs[29], &fr->fp); > - __put_user(env->xregs[30], &fr->lr); > - > - if (ka->sa_flags & TARGET_SA_RESTORER) { > - return_addr = ka->sa_restorer; > - } else { > - /* > - * mov x8,#__NR_rt_sigreturn; svc #0 > - * Since these are instructions they need to be put as little-endian > - * regardless of target default or current CPU endianness. > - */ > - __put_user_e(0xd2801168, &fr->tramp[0], le); > - __put_user_e(0xd4000001, &fr->tramp[1], le); > - return_addr = frame_addr + fr_ofs > - + offsetof(struct target_rt_frame_record, tramp); > - } > - env->xregs[0] = usig; > - env->xregs[31] = frame_addr; > - env->xregs[29] = frame_addr + fr_ofs; > - env->pc = ka->_sa_handler; > - env->xregs[30] = return_addr; > - if (info) { > - tswap_siginfo(&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_sigsegv(usig); > -} > - > -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 = NULL; > - abi_ulong frame_addr = env->xregs[31]; > - > - trace_user_do_rt_sigreturn(env, frame_addr); > - 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 -TARGET_QEMU_ESIGRETURN; > - > - badframe: > - unlock_user_struct(frame, frame_addr, 0); > - force_sig(TARGET_SIGSEGV); > - return -TARGET_QEMU_ESIGRETURN; > -} > - > -long do_sigreturn(CPUARMState *env) > -{ > - return do_rt_sigreturn(env); > -} > - > -#elif defined(TARGET_ARM) > +#elif defined(TARGET_ARM) && !defined(TARGET_AARCH64) > > struct target_sigcontext { > abi_ulong trap_no; -- Alex Bennée
