| |
| /*--------------------------------------------------------------------*/ |
| /*--- Create/destroy signal delivery frames. ---*/ |
| /*--- sigframe-amd64-darwin.c ---*/ |
| /*--------------------------------------------------------------------*/ |
| |
| /* |
| This file is part of Valgrind, a dynamic binary instrumentation |
| framework. |
| |
| Copyright (C) 2006-2015 OpenWorks Ltd |
| info@open-works.co.uk |
| |
| 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_amd64_darwin) |
| |
| #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_signals.h" |
| #include "pub_core_tooliface.h" |
| #include "pub_core_trampoline.h" |
| #include "pub_core_sigframe.h" /* self */ |
| #include "priv_sigframe.h" |
| |
| |
| /* Originally copied from ppc32-aix5 code. |
| Produce a frame with layout entirely of our own choosing. |
| |
| This module creates and removes signal frames for signal deliveries |
| on amd64-darwin. The machine state is saved in a ucontext and retrieved |
| from it later, so the handler can modify it and return. |
| |
| Frame should have a 16-aligned size, just in case that turns out to |
| be important for Darwin. (be conservative) |
| */ |
| struct hacky_sigframe { |
| /* first word looks like a call to a 3-arg amd64-ELF function */ |
| ULong returnAddr; |
| UChar lower_guardzone[512]; // put nothing here |
| VexGuestAMD64State vex; |
| VexGuestAMD64State vex_shadow1; |
| VexGuestAMD64State vex_shadow2; |
| vki_siginfo_t fake_siginfo; |
| struct vki_ucontext fake_ucontext; |
| UInt magicPI; |
| UInt sigNo_private; |
| vki_sigset_t mask; // saved sigmask; restore when hdlr returns |
| UChar upper_guardzone[512]; // put nothing here |
| // and don't zero it, since that might overwrite the client's |
| // stack redzone, at least on archs which have one |
| }; |
| |
| /* Create a plausible-looking sigcontext from the thread's |
| Vex guest state. NOTE: does not fill in the FP or SSE |
| bits of sigcontext at the moment. |
| */ |
| static void synthesize_ucontext(ThreadState *tst, |
| struct vki_ucontext *uc, |
| const struct vki_ucontext *siguc) |
| { |
| VG_(memset)(uc, 0, sizeof(*uc)); |
| |
| if (siguc) uc->uc_sigmask = siguc->uc_sigmask; |
| uc->uc_stack = tst->altstack; |
| uc->uc_mcontext = &uc->__mcontext_data; |
| |
| # define SC2(reg,REG) uc->__mcontext_data.__ss.reg = tst->arch.vex.guest_##REG |
| SC2(__r8,R8); |
| SC2(__r9,R9); |
| SC2(__r10,R10); |
| SC2(__r11,R11); |
| SC2(__r12,R12); |
| SC2(__r13,R13); |
| SC2(__r14,R14); |
| SC2(__r15,R15); |
| SC2(__rdi,RDI); |
| SC2(__rsi,RSI); |
| SC2(__rbp,RBP); |
| SC2(__rbx,RBX); |
| SC2(__rdx,RDX); |
| SC2(__rax,RAX); |
| SC2(__rcx,RCX); |
| SC2(__rsp,RSP); |
| SC2(__rip,RIP); |
| uc->__mcontext_data.__ss.__rflags = LibVEX_GuestAMD64_get_rflags(&tst->arch.vex); |
| |
| if (siguc) |
| uc->__mcontext_data.__es = siguc->__mcontext_data.__es; |
| # undef SC2 |
| } |
| |
| static void restore_from_ucontext(ThreadState *tst, |
| const struct vki_ucontext *uc) |
| { |
| # define SC2(REG,reg) tst->arch.vex.guest_##REG = uc->__mcontext_data.__ss.reg |
| SC2(R8,__r8); |
| SC2(R9,__r9); |
| SC2(R10,__r10); |
| SC2(R11,__r11); |
| SC2(R12,__r12); |
| SC2(R13,__r13); |
| SC2(R14,__r14); |
| SC2(R15,__r15); |
| SC2(RDI,__rdi); |
| SC2(RSI,__rsi); |
| SC2(RBP,__rbp); |
| SC2(RBX,__rbx); |
| SC2(RDX,__rdx); |
| SC2(RAX,__rax); |
| SC2(RCX,__rcx); |
| SC2(RSP,__rsp); |
| SC2(RIP,__rip); |
| /* There doesn't seem to be an easy way to restore rflags */ |
| # undef SC2 |
| } |
| |
| /* Create a signal frame for thread 'tid'. Make a 3-arg frame |
| regardless of whether the client originally requested a 1-arg |
| version (no SA_SIGINFO) or a 3-arg one (SA_SIGINFO) since in the |
| former case, the amd64 calling conventions will simply cause the |
| extra 2 args to be ignored (inside the handler). (We hope!) */ |
| 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 ) |
| { |
| ThreadState* tst; |
| Addr rsp; |
| struct hacky_sigframe* frame; |
| Int sigNo = siginfo->si_signo; |
| |
| vg_assert(VG_IS_16_ALIGNED(sizeof(struct hacky_sigframe))); |
| |
| sp_top_of_frame &= ~0xfUL; |
| rsp = sp_top_of_frame - sizeof(struct hacky_sigframe); |
| rsp -= 8; /* ELF ABI says that rsp+8 must be 16 aligned on |
| entry to a function. */ |
| |
| tst = VG_(get_ThreadState)(tid); |
| if (! ML_(sf_maybe_extend_stack)(tst, rsp, sp_top_of_frame - rsp, flags)) |
| return; |
| |
| vg_assert(VG_IS_16_ALIGNED(rsp+8)); |
| |
| frame = (struct hacky_sigframe *) rsp; |
| |
| /* clear it (very conservatively) */ |
| VG_(memset)(&frame->lower_guardzone, 0, sizeof frame->lower_guardzone); |
| VG_(memset)(&frame->vex, 0, sizeof(VexGuestAMD64State)); |
| VG_(memset)(&frame->vex_shadow1, 0, sizeof(VexGuestAMD64State)); |
| VG_(memset)(&frame->vex_shadow2, 0, sizeof(VexGuestAMD64State)); |
| VG_(memset)(&frame->fake_siginfo, 0, sizeof(frame->fake_siginfo)); |
| VG_(memset)(&frame->fake_ucontext, 0, sizeof(frame->fake_ucontext)); |
| |
| /* save stuff in frame */ |
| frame->vex = tst->arch.vex; |
| frame->vex_shadow1 = tst->arch.vex_shadow1; |
| frame->vex_shadow2 = tst->arch.vex_shadow2; |
| frame->sigNo_private = sigNo; |
| frame->mask = tst->sig_mask; |
| frame->magicPI = 0x31415927; |
| |
| /* Fill in the siginfo and ucontext. */ |
| synthesize_ucontext(tst, &frame->fake_ucontext, siguc); |
| frame->fake_siginfo = *siginfo; |
| |
| /* Set up stack pointer */ |
| vg_assert(rsp == (Addr)&frame->returnAddr); |
| VG_(set_SP)(tid, rsp); |
| VG_TRACK( post_reg_write, Vg_CoreSignal, tid, VG_O_STACK_PTR, sizeof(ULong)); |
| |
| /* Set up program counter */ |
| VG_(set_IP)(tid, (ULong)handler); |
| VG_TRACK( post_reg_write, Vg_CoreSignal, tid, VG_O_INSTR_PTR, sizeof(ULong)); |
| |
| /* Set up RA and args for the frame */ |
| VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal handler frame", |
| (Addr)frame, 1*sizeof(ULong) ); |
| frame->returnAddr = (ULong)&VG_(amd64_darwin_SUBST_FOR_sigreturn); |
| |
| /* XXX should tell the tool that these regs got written */ |
| tst->arch.vex.guest_RDI = (ULong) sigNo; |
| tst->arch.vex.guest_RSI = (Addr) &frame->fake_siginfo; |
| tst->arch.vex.guest_RDX = (Addr) &frame->fake_ucontext; |
| |
| VG_TRACK( post_mem_write, Vg_CoreSignal, tid, |
| (Addr)frame, 1*sizeof(ULong) ); |
| VG_TRACK( post_mem_write, Vg_CoreSignal, tid, |
| (Addr)&frame->fake_siginfo, sizeof(frame->fake_siginfo)); |
| VG_TRACK( post_mem_write, Vg_CoreSignal, tid, |
| (Addr)&frame->fake_ucontext, sizeof(frame->fake_ucontext)); |
| |
| if (VG_(clo_trace_signals)) |
| VG_(message)(Vg_DebugMsg, |
| "sigframe_create (thread %u): " |
| "next RIP=%#lx, next RSP=%#lx\n", |
| tid, (Addr)handler, (Addr)frame ); |
| } |
| |
| |
| /* Remove a signal frame from thread 'tid's stack, and restore the CPU |
| state from it. Note, isRT is irrelevant here. */ |
| void VG_(sigframe_destroy)( ThreadId tid, Bool isRT ) |
| { |
| ThreadState *tst; |
| Addr rsp; |
| Int sigNo; |
| struct hacky_sigframe* frame; |
| |
| vg_assert(VG_(is_valid_tid)(tid)); |
| tst = VG_(get_ThreadState)(tid); |
| |
| /* Check that the stack frame looks valid */ |
| rsp = VG_(get_SP)(tid); |
| |
| /* why -8 ? because the signal handler's return will have popped |
| the return address off the stack; and the return address is the |
| lowest-addressed element of hacky_sigframe. */ |
| frame = (struct hacky_sigframe*)(rsp - 8); |
| vg_assert(frame->magicPI == 0x31415927); |
| |
| /* This +8 is because of the -8 referred to in the ELF ABI comment |
| in VG_(sigframe_create) just above. */ |
| vg_assert(VG_IS_16_ALIGNED((Addr)frame + 8)); |
| |
| /* restore the entire guest state, and shadows, from the frame. */ |
| tst->arch.vex = frame->vex; |
| tst->arch.vex_shadow1 = frame->vex_shadow1; |
| tst->arch.vex_shadow2 = frame->vex_shadow2; |
| restore_from_ucontext(tst, &frame->fake_ucontext); |
| |
| tst->sig_mask = frame->mask; |
| tst->tmp_sig_mask = frame->mask; |
| sigNo = frame->sigNo_private; |
| |
| if (VG_(clo_trace_signals)) |
| VG_(message)(Vg_DebugMsg, |
| "sigframe_destroy (thread %d): " |
| "valid magic; next RIP=%#llx\n", |
| tid, tst->arch.vex.guest_RIP); |
| |
| VG_TRACK( die_mem_stack_signal, |
| (Addr)frame - VG_STACK_REDZONE_SZB, |
| sizeof(struct hacky_sigframe) ); |
| |
| /* tell the tools */ |
| VG_TRACK( post_deliver_signal, tid, sigNo ); |
| } |
| |
| #endif // defined(VGP_amd64_darwin) |
| |
| /*--------------------------------------------------------------------*/ |
| /*--- end sigframe-amd64-darwin.c ---*/ |
| /*--------------------------------------------------------------------*/ |
