zenithsiz/ftmemsim-valgrind
1
0
Fork 0
mirror of https://github.com/Zenithsiz/ftmemsim-valgrind.git synced 2026-02-03 18:13:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
ftmemsim-valgrind/coregrind/m_sigframe/sigframe-ppc64-linux.c
Carl Love 6f8920fd8f PPC64, fix for alignment of the rt_sigframe data structure. 
The PPC64 implementation checks that the data structure is aligned.  The
changes in commit listed below breaks the alignment.  This patch adds an
explicit alignment directive to ensure the data structure is allocated
with the required alignment.  This fixes 31 stderr failures, 10 stdout
failures on the Power 7, Power 8 and Power 9 platforms.

commit 3bac39a10abf292d332bb20ab58c6dd5c28f9108
Author: Eugene Syromyatnikov <evgsyr@gmail.com>
Date:   Fri Mar 8 04:07:00 2019 +0100

    include/vki: fix vki_siginfo_t definition on amd64, arm64, and ppc64

    As it turned out, the size of vki_siginfo_t is incorrect on these 64-bit
    architectures:

        (gdb) p sizeof(vki_siginfo_t)
        $1 = 136
        (gdb) ptype struct vki_siginfo
        type = struct vki_siginfo {
            int si_signo;
            int si_errno;
            int si_code;
            union {
                int _pad[29];
                struct {...} _kill;
                struct {...} _timer;
                struct {...} _rt;
                struct {...} _sigchld;
                struct {...} _sigfault;
                struct {...} _sigpoll;
            } _sifields;
        }
  etc.
2020-02-21 17:22:26 -06:00

359 lines
13 KiB
C
Raw Permalink Blame History

/*--------------------------------------------------------------------*/
/*--- Create/destroy signal delivery frames. ---*/
/*--- sigframe-ppc64-linux.c ---*/
/*--------------------------------------------------------------------*/
/*
This file is part of Valgrind, a dynamic binary instrumentation
framework.
Copyright (C) 2000-2017 Nicholas Nethercote
njn@valgrind.org
Copyright (C) 2004-2017 Paul Mackerras
paulus@samba.org
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/>.
The GNU General Public License is contained in the file COPYING.
*/
#if defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux)
#include "pub_core_basics.h"
#include "pub_core_vki.h"
#include "pub_core_vkiscnums.h"
#include "pub_core_threadstate.h"
#include "pub_core_aspacemgr.h"
#include "pub_core_libcbase.h"
#include "pub_core_libcassert.h"
#include "pub_core_libcprint.h"
#include "pub_core_machine.h"
#include "pub_core_options.h"
#include "pub_core_sigframe.h"
#include "pub_core_signals.h"
#include "pub_core_tooliface.h"
#include "pub_core_trampoline.h"
#include "pub_core_transtab.h" // VG_(discard_translations)
#include "priv_sigframe.h"
/* This module creates and removes signal frames for signal deliveries
on ppc64-linux.
Note, this file contains kernel-specific knowledge in the form of
'struct sigframe' and 'struct rt_sigframe'. How does that relate
to the vki kernel interface stuff?
Either a 'struct sigframe' or a 'struct rtsigframe' is pushed
onto the client's stack. This contains a subsidiary
vki_ucontext. That holds the vcpu's state across the signal,
so that the sighandler can mess with the vcpu state if it
really wants.
FIXME: sigcontexting is basically broken for the moment. When
delivering a signal, the integer registers and %eflags are
correctly written into the sigcontext, however the FP and SSE state
is not. When returning from a signal, only the integer registers
are restored from the sigcontext; the rest of the CPU state is
restored to what it was before the signal.
This will be fixed.
*/
/*------------------------------------------------------------*/
/*--- Signal frame layouts ---*/
/*------------------------------------------------------------*/
// A structure in which to save the application's registers
// during the execution of signal handlers.
// On ppc64-linux, rt_sigframe is used for all signals.
// In theory, so long as we get the arguments to the handler function
// right, it doesn't matter what the exact layout of the rest of the
// frame is. Unfortunately, things like gcc's exception unwinding
// make assumptions about the locations of various parts of the frame,
// so we need to duplicate it exactly.
/* Many of these byzantine details derived from
linux-2.6.13/arch/ppc64/kernel/signal.c */
#define TRAMP_SIZE 6 /* who knows why - it only needs to be 2. */
/* Structure containing bits of information that we want to save
on signal delivery. */
struct vg_sig_private {
UInt magicPI;
UInt sigNo_private;
ULong _unused; /* makes the struct size be zero % 16 */
VexGuestPPC64State vex_shadow1;
VexGuestPPC64State vex_shadow2;
};
/* Structure put on stack for all signal handlers. */
struct rt_sigframe {
struct vki_ucontext uc;
ULong _unused[2];
UInt tramp[TRAMP_SIZE];
struct vki_siginfo* pinfo;
void* puc;
vki_siginfo_t info;
struct vg_sig_private priv;
UChar abigap[288]; // unused
} __attribute__ ((aligned (16)));
#define SET_SIGNAL_LR(zztst, zzval) \
do { tst->arch.vex.guest_LR = (zzval); \
VG_TRACK( post_reg_write, Vg_CoreSignal, tst->tid, \
offsetof(VexGuestPPC64State,guest_LR), \
sizeof(UWord) ); \
} while (0)
#define SET_SIGNAL_GPR(zztst, zzn, zzval) \
do { tst->arch.vex.guest_GPR##zzn = (zzval); \
VG_TRACK( post_reg_write, Vg_CoreSignal, tst->tid, \
offsetof(VexGuestPPC64State,guest_GPR##zzn), \
sizeof(UWord) ); \
} while (0)
/* EXPORTED */
void VG_(sigframe_create)( ThreadId tid,
Bool on_altstack,
Addr sp_top_of_frame,
const vki_siginfo_t *siginfo,
const struct vki_ucontext *siguc,
void *handler,
UInt flags,
const vki_sigset_t *mask,
void *restorer )
{
struct vg_sig_private* priv;
Addr sp;
ThreadState* tst;
Int sigNo = siginfo->si_signo;
/* Addr faultaddr; */ /* UNUSED */
struct rt_sigframe* frame;
/* Stack must be 16-byte aligned */
vg_assert(VG_IS_16_ALIGNED(sizeof(struct vg_sig_private)));
vg_assert(VG_IS_16_ALIGNED(sizeof(struct rt_sigframe)));
sp_top_of_frame &= ~0xf;
sp = sp_top_of_frame - sizeof(struct rt_sigframe);
tst = VG_(get_ThreadState)(tid);
if (! ML_(sf_maybe_extend_stack)(tst, sp, sp_top_of_frame - sp, flags))
return;
vg_assert(VG_IS_16_ALIGNED(sp));
frame = (struct rt_sigframe *) sp;
/* clear it (conservatively) */
VG_(memset)(frame, 0, sizeof(*frame));
/////////
frame->pinfo = &frame->info;
frame->puc = &frame->uc;
frame->uc.uc_flags = 0;
frame->uc.uc_link = 0;
/////////
/* Set up the stack chain pointer */
VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal handler frame",
sp, sizeof(UWord) );
*(Addr *)sp = tst->arch.vex.guest_GPR1;
VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
sp, sizeof(UWord) );
/* UNUSED:
faultaddr = (Addr)siginfo->_sifields._sigfault._addr;
if (sigNo == VKI_SIGILL && siginfo->si_code > 0)
faultaddr = tst->arch.vex.guest_CIA;
*/
VG_(memcpy)(&frame->info, siginfo, sizeof(*siginfo));
VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
(Addr)&frame->info, sizeof(frame->info) );
frame->uc.uc_flags = 0;
frame->uc.uc_link = 0;
frame->uc.uc_stack = tst->altstack;
frame->uc.uc_sigmask = tst->sig_mask;
VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
(Addr)(&frame->uc), sizeof(frame->uc) );
# define DO(gpr) frame->uc.uc_mcontext.gp_regs[VKI_PT_R0+gpr] \
= tst->arch.vex.guest_GPR##gpr
DO(0); DO(1); DO(2); DO(3); DO(4); DO(5); DO(6); DO(7);
DO(8); DO(9); DO(10); DO(11); DO(12); DO(13); DO(14); DO(15);
DO(16); DO(17); DO(18); DO(19); DO(20); DO(21); DO(22); DO(23);
DO(24); DO(25); DO(26); DO(27); DO(28); DO(29); DO(30); DO(31);
# undef DO
frame->uc.uc_mcontext.gp_regs[VKI_PT_NIP] = tst->arch.vex.guest_CIA;
#ifdef VGP_ppc64le_linux
frame->uc.uc_mcontext.gp_regs[VKI_PT_MSR] = 0xf033; /* pretty arbitrary */
#else
frame->uc.uc_mcontext.gp_regs[VKI_PT_MSR] = 0xf032; /* pretty arbitrary */
#endif
frame->uc.uc_mcontext.gp_regs[VKI_PT_ORIG_R3] = tst->arch.vex.guest_GPR3;
frame->uc.uc_mcontext.gp_regs[VKI_PT_CTR] = tst->arch.vex.guest_CTR;
frame->uc.uc_mcontext.gp_regs[VKI_PT_LNK] = tst->arch.vex.guest_LR;
frame->uc.uc_mcontext.gp_regs[VKI_PT_XER] = LibVEX_GuestPPC64_get_XER(
&tst->arch.vex);
frame->uc.uc_mcontext.gp_regs[VKI_PT_CCR] = LibVEX_GuestPPC64_get_CR(
&tst->arch.vex);
//mc->mc_gregs[VKI_PT_MQ] = 0;
//mc->mc_gregs[VKI_PT_TRAP] = 0;
//mc->mc_gregs[VKI_PT_DAR] = fault_addr;
//mc->mc_gregs[VKI_PT_DSISR] = 0;
//mc->mc_gregs[VKI_PT_RESULT] = 0;
/* XXX should do FP and vector regs */
/* set up signal return trampoline */
/* NB. 5 Sept 07. mc->mc_pad[0..1] used to contain a the code to
which the signal handler returns, and it just did sys_sigreturn
or sys_rt_sigreturn. But this doesn't work if the stack is
non-executable, and it isn't consistent with the x86-linux and
amd64-linux scheme for removing the stack frame. So instead be
consistent and use a stub in m_trampoline. Then it doesn't
matter whether or not the (guest) stack is executable. This
fixes #149519 and #145837. */
frame->tramp[0] = 0; /* invalid */
frame->tramp[1] = 0; /* invalid */
VG_TRACK(post_mem_write, Vg_CoreSignal, tst->tid,
(Addr)&frame->tramp, sizeof(frame->tramp));
/* invalidate any translation of this area */
VG_(discard_translations)( (Addr)&frame->tramp[0],
sizeof(frame->tramp), "stack_mcontext" );
/* set the signal handler to return to the trampoline */
SET_SIGNAL_LR(tst, (Addr)&VG_(ppc64_linux_SUBST_FOR_rt_sigreturn));
/* Stack pointer for the handler .. (note, back chain set
earlier) */
SET_SIGNAL_GPR(tid, 1, sp);
/* Args for the handler .. */
SET_SIGNAL_GPR(tid, 3, sigNo);
SET_SIGNAL_GPR(tid, 4, (Addr) &frame->info);
SET_SIGNAL_GPR(tid, 5, (Addr) &frame->uc);
/* the kernel sets this, though it doesn't seem to be in the ABI */
SET_SIGNAL_GPR(tid, 6, (Addr) &frame->info);
/* Handler is in fact a standard ppc64-linux function descriptor,
so extract the function entry point and also the toc ptr to use. */
#if defined(VGP_ppc64be_linux)
SET_SIGNAL_GPR(tid, 2, (Addr) ((ULong*)handler)[1]);
tst->arch.vex.guest_CIA = (Addr) ((ULong*)handler)[0];
#else
SET_SIGNAL_GPR(tid, 12, (Addr) handler);
tst->arch.vex.guest_CIA = (Addr) handler;
#endif
priv = &frame->priv;
priv->magicPI = 0x31415927;
priv->sigNo_private = sigNo;
priv->vex_shadow1 = tst->arch.vex_shadow1;
priv->vex_shadow2 = tst->arch.vex_shadow2;
if (0)
VG_(printf)("pushed signal frame; %%R1 now = %#lx, "
"next %%CIA = %#llx, status=%d\n",
sp, tst->arch.vex.guest_CIA, (Int)tst->status);
}
/*------------------------------------------------------------*/
/*--- Destroying signal frames ---*/
/*------------------------------------------------------------*/
/* EXPORTED */
void VG_(sigframe_destroy)( ThreadId tid, Bool isRT )
{
ThreadState *tst;
struct vg_sig_private *priv;
Addr sp;
UInt frame_size;
struct rt_sigframe *frame;
Int sigNo;
Bool has_siginfo = isRT;
vg_assert(VG_(is_valid_tid)(tid));
tst = VG_(get_ThreadState)(tid);
/* Check that the stack frame looks valid */
sp = tst->arch.vex.guest_GPR1;
vg_assert(VG_IS_16_ALIGNED(sp));
/* JRS 17 Nov 05: This code used to check that *sp -- which should
have been set by the stwu at the start of the handler -- points
to just above the frame (ie, the previous frame). However, that
isn't valid when delivering signals on alt stacks. So I removed
it. The frame is still sanity-checked using the priv->magicPI
field. */
frame = (struct rt_sigframe *)sp;
frame_size = sizeof(*frame);
priv = &frame->priv;
vg_assert(priv->magicPI == 0x31415927);
tst->sig_mask = frame->uc.uc_sigmask;
tst->tmp_sig_mask = tst->sig_mask;
sigNo = priv->sigNo_private;
# define DO(gpr) tst->arch.vex.guest_GPR##gpr \
= frame->uc.uc_mcontext.gp_regs[VKI_PT_R0+gpr]
DO(0); DO(1); DO(2); DO(3); DO(4); DO(5); DO(6); DO(7);
DO(8); DO(9); DO(10); DO(11); DO(12); DO(13); DO(14); DO(15);
DO(16); DO(17); DO(18); DO(19); DO(20); DO(21); DO(22); DO(23);
DO(24); DO(25); DO(26); DO(27); DO(28); DO(29); DO(30); DO(31);
# undef DO
tst->arch.vex.guest_CIA = frame->uc.uc_mcontext.gp_regs[VKI_PT_NIP];
LibVEX_GuestPPC64_put_CR( frame->uc.uc_mcontext.gp_regs[VKI_PT_CCR],
&tst->arch.vex );
tst->arch.vex.guest_LR = frame->uc.uc_mcontext.gp_regs[VKI_PT_LNK];
tst->arch.vex.guest_CTR = frame->uc.uc_mcontext.gp_regs[VKI_PT_CTR];
LibVEX_GuestPPC64_put_XER( frame->uc.uc_mcontext.gp_regs[VKI_PT_XER],
&tst->arch.vex );
tst->arch.vex_shadow1 = priv->vex_shadow1;
tst->arch.vex_shadow2 = priv->vex_shadow2;
VG_TRACK(die_mem_stack_signal, sp, frame_size);
if (VG_(clo_trace_signals))
VG_(message)(Vg_DebugMsg,
"vg_pop_signal_frame (thread %u): isRT=%d "
"valid magic; EIP=%#llx\n",
tid, has_siginfo, tst->arch.vex.guest_CIA);
/* tell the tools */
VG_TRACK( post_deliver_signal, tid, sigNo );
}
#endif // defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux)
/*--------------------------------------------------------------------*/
/*--- end ---*/
/*--------------------------------------------------------------------*/
Reference in New Issue View Git Blame Copy Permalink