qemu/linux-user/openrisc/signal.c
Richard Henderson ddc3e74d9c linux-user: Pass CPUArchState to target_restore_altstack
In most cases we were already passing get_sp_from_cpustate
directly to the function.  In other cases, we were passing
a local variable which already contained the same value.
In the rest of the cases, we were passing the stack pointer
out of env directly.

Reviewed by: Warner Losh <imp@bsdimp.com>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20210426025334.1168495-5-richard.henderson@linaro.org>
Signed-off-by: Laurent Vivier <laurent@vivier.eu>
2021-05-15 21:43:23 +02:00

171 lines
4.9 KiB
C

/*
* 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 "signal-common.h"
#include "linux-user/trace.h"
typedef struct target_sigcontext {
struct target_pt_regs regs;
abi_ulong oldmask;
} target_sigcontext;
typedef struct target_ucontext {
abi_ulong tuc_flags;
abi_ulong tuc_link;
target_stack_t tuc_stack;
target_sigcontext tuc_mcontext;
target_sigset_t tuc_sigmask; /* mask last for extensibility */
} target_ucontext;
typedef struct target_rt_sigframe {
struct target_siginfo info;
target_ucontext uc;
uint32_t retcode[4]; /* trampoline code */
} target_rt_sigframe;
static void restore_sigcontext(CPUOpenRISCState *env, target_sigcontext *sc)
{
int i;
abi_ulong v;
for (i = 0; i < 32; ++i) {
__get_user(v, &sc->regs.gpr[i]);
cpu_set_gpr(env, i, v);
}
__get_user(env->pc, &sc->regs.pc);
/* Make sure the supervisor flag is clear. */
__get_user(v, &sc->regs.sr);
cpu_set_sr(env, v & ~SR_SM);
}
/* Set up a signal frame. */
static void setup_sigcontext(target_sigcontext *sc, CPUOpenRISCState *env)
{
int i;
for (i = 0; i < 32; ++i) {
__put_user(cpu_get_gpr(env, i), &sc->regs.gpr[i]);
}
__put_user(env->pc, &sc->regs.pc);
__put_user(cpu_get_sr(env), &sc->regs.sr);
}
static inline abi_ulong get_sigframe(struct target_sigaction *ka,
CPUOpenRISCState *env,
size_t frame_size)
{
target_ulong sp = get_sp_from_cpustate(env);
/* Honor redzone now. If we swap to signal stack, no need to waste
* the 128 bytes by subtracting afterward.
*/
sp -= 128;
sp = target_sigsp(sp, ka);
sp -= frame_size;
sp = QEMU_ALIGN_DOWN(sp, 4);
return sp;
}
void setup_rt_frame(int sig, struct target_sigaction *ka,
target_siginfo_t *info,
target_sigset_t *set, CPUOpenRISCState *env)
{
abi_ulong frame_addr;
target_rt_sigframe *frame;
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;
}
if (ka->sa_flags & SA_SIGINFO) {
tswap_siginfo(&frame->info, info);
}
__put_user(0, &frame->uc.tuc_flags);
__put_user(0, &frame->uc.tuc_link);
target_save_altstack(&frame->uc.tuc_stack, env);
setup_sigcontext(&frame->uc.tuc_mcontext, env);
for (i = 0; i < TARGET_NSIG_WORDS; ++i) {
__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
}
/* This is l.ori r11,r0,__NR_sigreturn; l.sys 1; l.nop; l.nop */
__put_user(0xa9600000 | TARGET_NR_rt_sigreturn, frame->retcode + 0);
__put_user(0x20000001, frame->retcode + 1);
__put_user(0x15000000, frame->retcode + 2);
__put_user(0x15000000, frame->retcode + 3);
/* Set up registers for signal handler */
cpu_set_gpr(env, 9, frame_addr + offsetof(target_rt_sigframe, retcode));
cpu_set_gpr(env, 3, sig);
cpu_set_gpr(env, 4, frame_addr + offsetof(target_rt_sigframe, info));
cpu_set_gpr(env, 5, frame_addr + offsetof(target_rt_sigframe, uc));
cpu_set_gpr(env, 1, frame_addr);
/* For debugging convenience, set ppc to the insn that faulted. */
env->ppc = env->pc;
/* When setting the PC for the signal handler, exit delay slot. */
env->pc = ka->_sa_handler;
env->dflag = 0;
return;
give_sigsegv:
unlock_user_struct(frame, frame_addr, 1);
force_sigsegv(sig);
}
long do_rt_sigreturn(CPUOpenRISCState *env)
{
abi_ulong frame_addr = get_sp_from_cpustate(env);
target_rt_sigframe *frame;
sigset_t set;
trace_user_do_rt_sigreturn(env, 0);
if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
goto badframe;
}
if (frame_addr & 3) {
goto badframe;
}
target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
set_sigmask(&set);
restore_sigcontext(env, &frame->uc.tuc_mcontext);
target_restore_altstack(&frame->uc.tuc_stack, env);
unlock_user_struct(frame, frame_addr, 0);
return cpu_get_gpr(env, 11);
badframe:
unlock_user_struct(frame, frame_addr, 0);
force_sig(TARGET_SIGSEGV);
return 0;
}