| /* | |
| * Emulation of Linux signals | |
| * | |
| * Copyright (c) 2003 Fabrice Bellard | |
| * | |
| * This program is free software; you can redistribute it and/or modify | |
| * it under the terms of the GNU General Public License as published by | |
| * the Free Software Foundation; either version 2 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * This program is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| * GNU General Public License for more details. | |
| * | |
| * 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 "user-internals.h" | |
| #include "signal-common.h" | |
| #include "linux-user/trace.h" | |
| # if defined(TARGET_ABI_MIPSO32) | |
| struct target_sigcontext { | |
| uint32_t sc_regmask; /* Unused */ | |
| uint32_t sc_status; | |
| uint64_t sc_pc; | |
| uint64_t sc_regs[32]; | |
| uint64_t sc_fpregs[32]; | |
| uint32_t sc_ownedfp; /* Unused */ | |
| uint32_t sc_fpc_csr; | |
| uint32_t sc_fpc_eir; /* Unused */ | |
| uint32_t sc_used_math; | |
| uint32_t sc_dsp; /* dsp status, was sc_ssflags */ | |
| uint32_t pad0; | |
| uint64_t sc_mdhi; | |
| uint64_t sc_mdlo; | |
| target_ulong sc_hi1; /* Was sc_cause */ | |
| target_ulong sc_lo1; /* Was sc_badvaddr */ | |
| target_ulong sc_hi2; /* Was sc_sigset[4] */ | |
| target_ulong sc_lo2; | |
| target_ulong sc_hi3; | |
| target_ulong sc_lo3; | |
| }; | |
| # else /* N32 || N64 */ | |
| struct target_sigcontext { | |
| uint64_t sc_regs[32]; | |
| uint64_t sc_fpregs[32]; | |
| uint64_t sc_mdhi; | |
| uint64_t sc_hi1; | |
| uint64_t sc_hi2; | |
| uint64_t sc_hi3; | |
| uint64_t sc_mdlo; | |
| uint64_t sc_lo1; | |
| uint64_t sc_lo2; | |
| uint64_t sc_lo3; | |
| uint64_t sc_pc; | |
| uint32_t sc_fpc_csr; | |
| uint32_t sc_used_math; | |
| uint32_t sc_dsp; | |
| uint32_t sc_reserved; | |
| }; | |
| # endif /* O32 */ | |
| struct sigframe { | |
| uint32_t sf_ass[4]; /* argument save space for o32 */ | |
| uint32_t sf_code[2]; /* signal trampoline */ | |
| struct target_sigcontext sf_sc; | |
| target_sigset_t sf_mask; | |
| }; | |
| struct target_ucontext { | |
| abi_ulong tuc_flags; | |
| abi_ulong tuc_link; | |
| target_stack_t tuc_stack; | |
| struct target_sigcontext tuc_mcontext; | |
| target_sigset_t tuc_sigmask; | |
| }; | |
| struct target_rt_sigframe { | |
| uint32_t rs_ass[4]; /* argument save space for o32 */ | |
| uint32_t rs_code[2]; /* signal trampoline */ | |
| struct target_siginfo rs_info; | |
| struct target_ucontext rs_uc; | |
| }; | |
| /* Install trampoline to jump back from signal handler */ | |
| static void install_sigtramp(uint32_t *tramp, unsigned int syscall) | |
| { | |
| /* | |
| * Set up the return code ... | |
| * | |
| * li v0, __NR__foo_sigreturn | |
| * syscall | |
| */ | |
| __put_user(0x24020000 + syscall, tramp + 0); | |
| __put_user(0x0000000c , tramp + 1); | |
| } | |
| static inline void setup_sigcontext(CPUMIPSState *regs, | |
| struct target_sigcontext *sc) | |
| { | |
| int i; | |
| __put_user(exception_resume_pc(regs), &sc->sc_pc); | |
| regs->hflags &= ~MIPS_HFLAG_BMASK; | |
| __put_user(0, &sc->sc_regs[0]); | |
| for (i = 1; i < 32; ++i) { | |
| __put_user(regs->active_tc.gpr[i], &sc->sc_regs[i]); | |
| } | |
| __put_user(regs->active_tc.HI[0], &sc->sc_mdhi); | |
| __put_user(regs->active_tc.LO[0], &sc->sc_mdlo); | |
| /* Rather than checking for dsp existence, always copy. The storage | |
| would just be garbage otherwise. */ | |
| __put_user(regs->active_tc.HI[1], &sc->sc_hi1); | |
| __put_user(regs->active_tc.HI[2], &sc->sc_hi2); | |
| __put_user(regs->active_tc.HI[3], &sc->sc_hi3); | |
| __put_user(regs->active_tc.LO[1], &sc->sc_lo1); | |
| __put_user(regs->active_tc.LO[2], &sc->sc_lo2); | |
| __put_user(regs->active_tc.LO[3], &sc->sc_lo3); | |
| { | |
| uint32_t dsp = cpu_rddsp(0x3ff, regs); | |
| __put_user(dsp, &sc->sc_dsp); | |
| } | |
| __put_user(1, &sc->sc_used_math); | |
| for (i = 0; i < 32; ++i) { | |
| __put_user(regs->active_fpu.fpr[i].d, &sc->sc_fpregs[i]); | |
| } | |
| __put_user(regs->active_fpu.fcr31, &sc->sc_fpc_csr); | |
| } | |
| static inline void | |
| restore_sigcontext(CPUMIPSState *regs, struct target_sigcontext *sc) | |
| { | |
| int i; | |
| __get_user(regs->CP0_EPC, &sc->sc_pc); | |
| __get_user(regs->active_tc.HI[0], &sc->sc_mdhi); | |
| __get_user(regs->active_tc.LO[0], &sc->sc_mdlo); | |
| for (i = 1; i < 32; ++i) { | |
| __get_user(regs->active_tc.gpr[i], &sc->sc_regs[i]); | |
| } | |
| __get_user(regs->active_tc.HI[1], &sc->sc_hi1); | |
| __get_user(regs->active_tc.HI[2], &sc->sc_hi2); | |
| __get_user(regs->active_tc.HI[3], &sc->sc_hi3); | |
| __get_user(regs->active_tc.LO[1], &sc->sc_lo1); | |
| __get_user(regs->active_tc.LO[2], &sc->sc_lo2); | |
| __get_user(regs->active_tc.LO[3], &sc->sc_lo3); | |
| { | |
| uint32_t dsp; | |
| __get_user(dsp, &sc->sc_dsp); | |
| cpu_wrdsp(dsp, 0x3ff, regs); | |
| } | |
| for (i = 0; i < 32; ++i) { | |
| __get_user(regs->active_fpu.fpr[i].d, &sc->sc_fpregs[i]); | |
| } | |
| { | |
| uint32_t fcr31; | |
| __get_user(fcr31, &sc->sc_fpc_csr); | |
| regs->active_fpu.fcr31 = fcr31 & regs->active_fpu.fcr31_rw_bitmask; | |
| cpu_mips_restore_fp_status(regs); | |
| } | |
| } | |
| /* | |
| * Determine which stack to use.. | |
| */ | |
| static inline abi_ulong | |
| get_sigframe(struct target_sigaction *ka, CPUMIPSState *regs, size_t frame_size) | |
| { | |
| unsigned long sp; | |
| /* | |
| * FPU emulator may have its own trampoline active just | |
| * above the user stack, 16-bytes before the next lowest | |
| * 16 byte boundary. Try to avoid trashing it. | |
| */ | |
| sp = target_sigsp(get_sp_from_cpustate(regs) - 32, ka); | |
| return (sp - frame_size) & ~7; | |
| } | |
| static void mips_set_hflags_isa_mode_from_pc(CPUMIPSState *env) | |
| { | |
| if (env->insn_flags & (ASE_MIPS16 | ASE_MICROMIPS)) { | |
| env->hflags &= ~MIPS_HFLAG_M16; | |
| env->hflags |= (env->active_tc.PC & 1) << MIPS_HFLAG_M16_SHIFT; | |
| env->active_tc.PC &= ~(target_ulong) 1; | |
| } | |
| } | |
| # if defined(TARGET_ABI_MIPSO32) | |
| /* compare linux/arch/mips/kernel/signal.c:setup_frame() */ | |
| void setup_frame(int sig, struct target_sigaction * ka, | |
| target_sigset_t *set, CPUMIPSState *regs) | |
| { | |
| struct sigframe *frame; | |
| abi_ulong frame_addr; | |
| int i; | |
| frame_addr = get_sigframe(ka, regs, sizeof(*frame)); | |
| trace_user_setup_frame(regs, frame_addr); | |
| if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { | |
| goto give_sigsegv; | |
| } | |
| setup_sigcontext(regs, &frame->sf_sc); | |
| for(i = 0; i < TARGET_NSIG_WORDS; i++) { | |
| __put_user(set->sig[i], &frame->sf_mask.sig[i]); | |
| } | |
| /* | |
| * Arguments to signal handler: | |
| * | |
| * a0 = signal number | |
| * a1 = 0 (should be cause) | |
| * a2 = pointer to struct sigcontext | |
| * | |
| * $25 and PC point to the signal handler, $29 points to the | |
| * struct sigframe. | |
| */ | |
| regs->active_tc.gpr[ 4] = sig; | |
| regs->active_tc.gpr[ 5] = 0; | |
| regs->active_tc.gpr[ 6] = frame_addr + offsetof(struct sigframe, sf_sc); | |
| regs->active_tc.gpr[29] = frame_addr; | |
| regs->active_tc.gpr[31] = default_sigreturn; | |
| /* The original kernel code sets CP0_EPC to the handler | |
| * since it returns to userland using eret | |
| * we cannot do this here, and we must set PC directly */ | |
| regs->active_tc.PC = regs->active_tc.gpr[25] = ka->_sa_handler; | |
| mips_set_hflags_isa_mode_from_pc(regs); | |
| unlock_user_struct(frame, frame_addr, 1); | |
| return; | |
| give_sigsegv: | |
| force_sigsegv(sig); | |
| } | |
| long do_sigreturn(CPUMIPSState *regs) | |
| { | |
| struct sigframe *frame; | |
| abi_ulong frame_addr; | |
| sigset_t blocked; | |
| target_sigset_t target_set; | |
| int i; | |
| frame_addr = regs->active_tc.gpr[29]; | |
| trace_user_do_sigreturn(regs, frame_addr); | |
| if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) | |
| goto badframe; | |
| for(i = 0; i < TARGET_NSIG_WORDS; i++) { | |
| __get_user(target_set.sig[i], &frame->sf_mask.sig[i]); | |
| } | |
| target_to_host_sigset_internal(&blocked, &target_set); | |
| set_sigmask(&blocked); | |
| restore_sigcontext(regs, &frame->sf_sc); | |
| #if 0 | |
| /* | |
| * Don't let your children do this ... | |
| */ | |
| __asm__ __volatile__( | |
| "move\t$29, %0\n\t" | |
| "j\tsyscall_exit" | |
| :/* no outputs */ | |
| :"r" (®s)); | |
| /* Unreached */ | |
| #endif | |
| regs->active_tc.PC = regs->CP0_EPC; | |
| mips_set_hflags_isa_mode_from_pc(regs); | |
| /* I am not sure this is right, but it seems to work | |
| * maybe a problem with nested signals ? */ | |
| regs->CP0_EPC = 0; | |
| return -QEMU_ESIGRETURN; | |
| badframe: | |
| force_sig(TARGET_SIGSEGV); | |
| return -QEMU_ESIGRETURN; | |
| } | |
| # endif /* O32 */ | |
| void setup_rt_frame(int sig, struct target_sigaction *ka, | |
| target_siginfo_t *info, | |
| target_sigset_t *set, CPUMIPSState *env) | |
| { | |
| struct target_rt_sigframe *frame; | |
| abi_ulong frame_addr; | |
| int i; | |
| frame_addr = get_sigframe(ka, env, sizeof(*frame)); | |
| trace_user_setup_rt_frame(env, frame_addr); | |
| if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { | |
| goto give_sigsegv; | |
| } | |
| frame->rs_info = *info; | |
| __put_user(0, &frame->rs_uc.tuc_flags); | |
| __put_user(0, &frame->rs_uc.tuc_link); | |
| target_save_altstack(&frame->rs_uc.tuc_stack, env); | |
| setup_sigcontext(env, &frame->rs_uc.tuc_mcontext); | |
| for (i = 0; i < TARGET_NSIG_WORDS; i++) { | |
| __put_user(set->sig[i], &frame->rs_uc.tuc_sigmask.sig[i]); | |
| } | |
| /* | |
| * Arguments to signal handler: | |
| * | |
| * a0 = signal number | |
| * a1 = pointer to siginfo_t | |
| * a2 = pointer to ucontext_t | |
| * | |
| * $25 and PC point to the signal handler, $29 points to the | |
| * struct sigframe. | |
| */ | |
| env->active_tc.gpr[ 4] = sig; | |
| env->active_tc.gpr[ 5] = frame_addr | |
| + offsetof(struct target_rt_sigframe, rs_info); | |
| env->active_tc.gpr[ 6] = frame_addr | |
| + offsetof(struct target_rt_sigframe, rs_uc); | |
| env->active_tc.gpr[29] = frame_addr; | |
| env->active_tc.gpr[31] = default_rt_sigreturn; | |
| /* | |
| * The original kernel code sets CP0_EPC to the handler | |
| * since it returns to userland using eret | |
| * we cannot do this here, and we must set PC directly | |
| */ | |
| env->active_tc.PC = env->active_tc.gpr[25] = ka->_sa_handler; | |
| mips_set_hflags_isa_mode_from_pc(env); | |
| unlock_user_struct(frame, frame_addr, 1); | |
| return; | |
| give_sigsegv: | |
| unlock_user_struct(frame, frame_addr, 1); | |
| force_sigsegv(sig); | |
| } | |
| long do_rt_sigreturn(CPUMIPSState *env) | |
| { | |
| struct target_rt_sigframe *frame; | |
| abi_ulong frame_addr; | |
| sigset_t blocked; | |
| frame_addr = env->active_tc.gpr[29]; | |
| trace_user_do_rt_sigreturn(env, frame_addr); | |
| if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { | |
| goto badframe; | |
| } | |
| target_to_host_sigset(&blocked, &frame->rs_uc.tuc_sigmask); | |
| set_sigmask(&blocked); | |
| restore_sigcontext(env, &frame->rs_uc.tuc_mcontext); | |
| target_restore_altstack(&frame->rs_uc.tuc_stack, env); | |
| env->active_tc.PC = env->CP0_EPC; | |
| mips_set_hflags_isa_mode_from_pc(env); | |
| /* I am not sure this is right, but it seems to work | |
| * maybe a problem with nested signals ? */ | |
| env->CP0_EPC = 0; | |
| return -QEMU_ESIGRETURN; | |
| badframe: | |
| force_sig(TARGET_SIGSEGV); | |
| return -QEMU_ESIGRETURN; | |
| } | |
| void setup_sigtramp(abi_ulong sigtramp_page) | |
| { | |
| uint32_t *tramp = lock_user(VERIFY_WRITE, sigtramp_page, 2 * 8, 0); | |
| assert(tramp != NULL); | |
| #ifdef TARGET_ARCH_HAS_SETUP_FRAME | |
| default_sigreturn = sigtramp_page; | |
| install_sigtramp(tramp, TARGET_NR_sigreturn); | |
| #endif | |
| default_rt_sigreturn = sigtramp_page + 8; | |
| install_sigtramp(tramp + 2, TARGET_NR_rt_sigreturn); | |
| unlock_user(tramp, sigtramp_page, 2 * 8); | |
| } |