Commit 1744aea1 authored by Andreas Schwab's avatar Andreas Schwab Committed by Peter Maydell
Browse files

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: default avatarAndreas Schwab <schwab@suse.de>
Signed-off-by: default avatarAlexander Graf <agraf@suse.de>
Signed-off-by: default avatarJohn Rigby <john.rigby@linaro.org>
Signed-off-by: default avatarPeter 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: default avatarPeter Maydell <peter.maydell@linaro.org>
parent 09701199

linux-user/aarch64/target_signal.h

0 → 100644
+29 −0
Original line number Diff line number Diff line 
#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 */

linux-user/signal.c

+260 −0
Original line number Diff line number Diff line
@@ -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 {