--- /dev/null
+
+/*--------------------------------------------------------------------*/
+/*--- Create/destroy signal delivery frames. ---*/
+/*--- sigframe-arm-linux.c ---*/
+/*--------------------------------------------------------------------*/
+
+/*
+ This file is part of Valgrind, a dynamic binary instrumentation
+ framework.
+
+ Copyright (C) 2000-2010 Nicholas Nethercote
+ njn@valgrind.org
+ Copyright (C) 2004-2010 Paul Mackerras
+ paulus@samba.org
+ Copyright (C) 2008-2010 Evan Geller
+ gaze@bea.ms
+
+ 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, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307, USA.
+
+ The GNU General Public License is contained in the file COPYING.
+*/
+
+#if defined(VGP_arm_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)
+
+
+struct vg_sig_private {
+ UInt magicPI;
+ UInt sigNo_private;
+ VexGuestARMState vex_shadow1;
+ VexGuestARMState vex_shadow2;
+};
+
+struct sigframe {
+ struct vki_ucontext uc;
+ unsigned long retcode[2];
+ struct vg_sig_private vp;
+};
+
+struct rt_sigframe {
+ vki_siginfo_t info;
+ struct sigframe sig;
+};
+
+static Bool extend ( ThreadState *tst, Addr addr, SizeT size )
+{
+ ThreadId tid = tst->tid;
+ NSegment const* stackseg = NULL;
+
+ if (VG_(extend_stack)(addr, tst->client_stack_szB)) {
+ stackseg = VG_(am_find_nsegment)(addr);
+ if (0 && stackseg)
+ VG_(printf)("frame=%#lx seg=%#lx-%#lx\n",
+ addr, stackseg->start, stackseg->end);
+ }
+
+ if (stackseg == NULL || !stackseg->hasR || !stackseg->hasW) {
+ VG_(message)(
+ Vg_UserMsg,
+ "Can't extend stack to %#lx during signal delivery for thread %d:",
+ addr, tid);
+ if (stackseg == NULL)
+ VG_(message)(Vg_UserMsg, " no stack segment");
+ else
+ VG_(message)(Vg_UserMsg, " too small or bad protection modes");
+
+ /* set SIGSEGV to default handler */
+ VG_(set_default_handler)(VKI_SIGSEGV);
+ VG_(synth_fault_mapping)(tid, addr);
+
+ /* The whole process should be about to die, since the default
+ action of SIGSEGV to kill the whole process. */
+ return False;
+ }
+
+ /* For tracking memory events, indicate the entire frame has been
+ allocated. */
+ VG_TRACK( new_mem_stack_signal, addr - VG_STACK_REDZONE_SZB,
+ size + VG_STACK_REDZONE_SZB, tid );
+
+ return True;
+}
+
+static void synth_ucontext( ThreadId tid, const vki_siginfo_t *si,
+ UWord trapno, UWord err, const vki_sigset_t *set,
+ struct vki_ucontext *uc){
+
+ ThreadState *tst = VG_(get_ThreadState)(tid);
+ struct vki_sigcontext *sc = &uc->uc_mcontext;
+
+ VG_(memset)(uc, 0, sizeof(*uc));
+
+ uc->uc_flags = 0;
+ uc->uc_link = 0;
+ uc->uc_sigmask = *set;
+ uc->uc_stack = tst->altstack;
+
+# define SC2(reg,REG) sc->arm_##reg = tst->arch.vex.guest_##REG
+ SC2(r0,R0);
+ SC2(r1,R1);
+ SC2(r2,R2);
+ SC2(r3,R3);
+ SC2(r4,R4);
+ SC2(r5,R5);
+ SC2(r6,R6);
+ SC2(r7,R7);
+ SC2(r8,R8);
+ SC2(r9,R9);
+ SC2(r10,R10);
+ SC2(fp,R11);
+ SC2(ip,R12);
+ SC2(sp,R13);
+ SC2(lr,R14);
+ SC2(pc,R15);
+# undef SC2
+
+ sc->trap_no = trapno;
+ sc->error_code = err;
+ sc->fault_address = (UInt)si->_sifields._sigfault._addr;
+}
+
+
+static void build_sigframe(ThreadState *tst,
+ struct sigframe *frame,
+ const vki_siginfo_t *siginfo,
+ const struct vki_ucontext *siguc,
+ void *handler, UInt flags,
+ const vki_sigset_t *mask,
+ void *restorer){
+
+ UWord trapno;
+ UWord err;
+ Int sigNo = siginfo->si_signo;
+ struct vg_sig_private *priv = &frame->vp;
+
+ VG_TRACK( pre_mem_write, Vg_CoreSignal, tst->tid, "signal handler frame",
+ (Addr)frame, offsetof(struct sigframe, vp));
+
+ if(siguc) {
+ trapno = siguc->uc_mcontext.trap_no;
+ err = siguc->uc_mcontext.error_code;
+ } else {
+ trapno = 0;
+ err = 0;
+ }
+
+ synth_ucontext(tst->tid, siginfo, trapno, err, mask, &frame->uc);
+
+ VG_TRACK( post_mem_write, Vg_CoreSignal, tst->tid,
+ (Addr)frame, offsetof(struct sigframe, vp));
+
+ priv->magicPI = 0x31415927;
+ priv->sigNo_private = sigNo;
+ priv->vex_shadow1 = tst->arch.vex_shadow1;
+ priv->vex_shadow2 = tst->arch.vex_shadow2;
+
+}
+
+
+
+/* EXPORTED */
+void VG_(sigframe_create)( ThreadId tid,
+ 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 = sp_top_of_frame;
+ ThreadState *tst;
+ Int sigNo = siginfo->si_signo;
+// Addr faultaddr;
+ UInt size;
+
+ tst = VG_(get_ThreadState)(tid);
+
+ size = flags & VKI_SA_SIGINFO ? sizeof(struct rt_sigframe) :
+ sizeof(struct sigframe);
+
+ sp -= size;
+ sp = VG_ROUNDDN(sp, 16);
+
+ if(!extend(tst, sp, size))
+ I_die_here; // XXX Incorrect behavior
+
+
+ if (flags & VKI_SA_SIGINFO){
+ struct rt_sigframe *rsf = (struct rt_sigframe *)sp;
+
+ /* Track our writes to siginfo */
+ VG_TRACK( pre_mem_write, Vg_CoreSignal, tst->tid, /* VVVVV */
+ "signal handler siginfo", (Addr)rsf,
+ offsetof(struct rt_sigframe, sig));
+
+ VG_(memcpy)(&rsf->info, siginfo, sizeof(vki_siginfo_t));
+
+ if(sigNo == VKI_SIGILL && siginfo->si_code > 0) {
+ rsf->info._sifields._sigfault._addr = (Addr *) (tst)->arch.vex.guest_R12; /* IP */
+ }
+ VG_TRACK( post_mem_write, Vg_CoreSignal, tst->tid, /* ^^^^^ */
+ (Addr)rsf, offsetof(struct rt_sigframe, sig));
+
+ build_sigframe(tst, &rsf->sig, siginfo, siguc,
+ handler, flags, mask, restorer);
+ tst->arch.vex.guest_R1 = (Addr)&rsf->info;
+ tst->arch.vex.guest_R2 = (Addr)&rsf->sig.uc;
+ }
+ else{
+ build_sigframe(tst, (struct sigframe *)sp, siginfo, siguc,
+ handler, flags, mask, restorer);
+ }
+
+ VG_(set_SP)(tid, sp);
+ VG_TRACK( post_reg_write, Vg_CoreSignal, tid, VG_O_STACK_PTR,
+ sizeof(Addr));
+ tst->arch.vex.guest_R0 = sigNo;
+
+ if(flags & VKI_SA_RESTORER)
+ tst->arch.vex.guest_R14 = (Addr) restorer;
+
+ tst->arch.vex.guest_R15 = (Addr) handler; /* R15 == PC */
+}
+
+
+/*------------------------------------------------------------*/
+/*--- 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 vki_sigcontext *mc;
+ Int sigNo;
+ Bool has_siginfo = isRT;
+
+ vg_assert(VG_(is_valid_tid)(tid));
+ tst = VG_(get_ThreadState)(tid);
+ sp = tst->arch.vex.guest_R13;
+
+ if (has_siginfo) {
+ struct rt_sigframe *frame = (struct rt_sigframe *)sp;
+ frame_size = sizeof(*frame);
+ mc = &frame->sig.uc.uc_mcontext;
+ priv = &frame->sig.vp;
+ vg_assert(priv->magicPI == 0x31415927);
+ tst->sig_mask = frame->sig.uc.uc_sigmask;
+ } else {
+ struct sigframe *frame = (struct sigframe *)sp;
+ frame_size = sizeof(*frame);
+ mc = &frame->uc.uc_mcontext;
+ priv = &frame->vp;
+ vg_assert(priv->magicPI == 0x31415927);
+ tst->sig_mask = frame->uc.uc_sigmask;
+ /*tst->sig_mask.sig[0] = frame->uc.uc_mcontext.oldmask;
+ tst->sig_mask.sig[1] = frame->uc.uc_mcontext._unused[3];
+ VG_(printf)("Setting signmask to %08x%08x\n",tst->sig_mask[0],tst->sig_mask[1]);
+*/
+ }
+ tst->tmp_sig_mask = tst->sig_mask;
+
+ sigNo = priv->sigNo_private;
+
+ //XXX: restore regs
+# define REST(reg,REG) tst->arch.vex.guest_##REG = mc->arm_##reg;
+ REST(r0,R0);
+ REST(r1,R1);
+ REST(r2,R2);
+ REST(r3,R3);
+ REST(r4,R4);
+ REST(r5,R5);
+ REST(r6,R6);
+ REST(r7,R7);
+ REST(r8,R8);
+ REST(r9,R9);
+ REST(r10,R10);
+ REST(fp,R11);
+ REST(ip,R12);
+ REST(sp,R13);
+ REST(lr,R14);
+ REST(pc,R15);
+# undef REST
+
+ tst->arch.vex_shadow1 = priv->vex_shadow1;
+ tst->arch.vex_shadow2 = priv->vex_shadow2;
+
+ VG_TRACK( die_mem_stack_signal, sp - VG_STACK_REDZONE_SZB,
+ frame_size + VG_STACK_REDZONE_SZB );
+
+ if (VG_(clo_trace_signals))
+ VG_(message)(Vg_DebugMsg,
+ "vg_pop_signal_frame (thread %d): isRT=%d valid magic; PC=%#x",
+ tid, has_siginfo, tst->arch.vex.guest_R15);
+
+ /* tell the tools */
+ VG_TRACK( post_deliver_signal, tid, sigNo );
+}
+
+#endif // defined(VGP_arm_linux)
+
+/*--------------------------------------------------------------------*/
+/*--- end sigframe-arm-linux.c ---*/
+/*--------------------------------------------------------------------*/
projects / l4.git / blobdiff