1 2 /*--------------------------------------------------------------------*/ 3 /*--- Create/destroy signal delivery frames. ---*/ 4 /*--- sigframe-amd64-darwin.c ---*/ 5 /*--------------------------------------------------------------------*/ 6 7 /* 8 This file is part of Valgrind, a dynamic binary instrumentation 9 framework. 10 11 Copyright (C) 2006-2013 OpenWorks Ltd 12 info (at) open-works.co.uk 13 14 This program is free software; you can redistribute it and/or 15 modify it under the terms of the GNU General Public License as 16 published by the Free Software Foundation; either version 2 of the 17 License, or (at your option) any later version. 18 19 This program is distributed in the hope that it will be useful, but 20 WITHOUT ANY WARRANTY; without even the implied warranty of 21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 22 General Public License for more details. 23 24 You should have received a copy of the GNU General Public License 25 along with this program; if not, write to the Free Software 26 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 27 02111-1307, USA. 28 29 The GNU General Public License is contained in the file COPYING. 30 */ 31 32 #if defined(VGP_amd64_darwin) 33 34 #include "pub_core_basics.h" 35 #include "pub_core_vki.h" 36 #include "pub_core_vkiscnums.h" 37 #include "pub_core_libcsetjmp.h" // to keep _threadstate.h happy 38 #include "pub_core_threadstate.h" 39 #include "pub_core_aspacemgr.h" 40 #include "pub_core_libcbase.h" 41 #include "pub_core_libcassert.h" 42 #include "pub_core_libcprint.h" 43 #include "pub_core_machine.h" 44 #include "pub_core_options.h" 45 #include "pub_core_signals.h" 46 #include "pub_core_tooliface.h" 47 #include "pub_core_trampoline.h" 48 #include "pub_core_sigframe.h" /* self */ 49 50 51 /* Cheap-ass hack copied from ppc32-aix5 code, just to get started. 52 Produce a frame with layout entirely of our own choosing. */ 53 54 /* This module creates and removes signal frames for signal deliveries 55 on amd64-darwin. Kludgey; the machine state ought to be saved in a 56 ucontext and retrieved from it later, so the handler can modify it 57 and return. However .. for now .. just stick the vex guest state 58 in the frame and snarf it again later. 59 60 Also, don't bother with creating siginfo and ucontext in the 61 handler, although do point them somewhere non-faulting. 62 63 Frame should have a 16-aligned size, just in case that turns out to 64 be important for Darwin. (be conservative) 65 */ 66 struct hacky_sigframe { 67 /* first word looks like a call to a 3-arg amd64-ELF function */ 68 ULong returnAddr; 69 UChar lower_guardzone[512]; // put nothing here 70 VexGuestAMD64State gst; 71 VexGuestAMD64State gshadow1; 72 VexGuestAMD64State gshadow2; 73 vki_siginfo_t fake_siginfo; 74 struct vki_ucontext fake_ucontext; 75 UInt magicPI; 76 UInt sigNo_private; 77 vki_sigset_t mask; // saved sigmask; restore when hdlr returns 78 UInt __pad[2]; 79 UChar upper_guardzone[512]; // put nothing here 80 // and don't zero it, since that might overwrite the client's 81 // stack redzone, at least on archs which have one 82 }; 83 84 85 /* Extend the stack segment downwards if needed so as to ensure the 86 new signal frames are mapped to something. Return a Bool 87 indicating whether or not the operation was successful. 88 */ 89 static Bool extend ( ThreadState *tst, Addr addr, SizeT size ) 90 { 91 ThreadId tid = tst->tid; 92 VG_TRACK( new_mem_stack_signal, addr - VG_STACK_REDZONE_SZB, 93 size + VG_STACK_REDZONE_SZB, tid ); 94 return True; 95 } 96 97 98 /* Create a signal frame for thread 'tid'. Make a 3-arg frame 99 regardless of whether the client originally requested a 1-arg 100 version (no SA_SIGINFO) or a 3-arg one (SA_SIGINFO) since in the 101 former case, the amd64 calling conventions will simply cause the 102 extra 2 args to be ignored (inside the handler). (We hope!) */ 103 void VG_(sigframe_create) ( ThreadId tid, 104 Addr sp_top_of_frame, 105 const vki_siginfo_t *siginfo, 106 const struct vki_ucontext *siguc, 107 void *handler, 108 UInt flags, 109 const vki_sigset_t *mask, 110 void *restorer ) 111 { 112 ThreadState* tst; 113 Addr rsp; 114 struct hacky_sigframe* frame; 115 Int sigNo = siginfo->si_signo; 116 117 vg_assert(VG_IS_16_ALIGNED(sizeof(struct hacky_sigframe))); 118 119 sp_top_of_frame &= ~0xfUL; 120 rsp = sp_top_of_frame - sizeof(struct hacky_sigframe); 121 rsp -= 8; /* ELF ABI says that rsp+8 must be 16 aligned on 122 entry to a function. */ 123 124 tst = VG_(get_ThreadState)(tid); 125 if (!extend(tst, rsp, sp_top_of_frame - rsp)) 126 return; 127 128 vg_assert(VG_IS_16_ALIGNED(rsp+8)); 129 130 frame = (struct hacky_sigframe *) rsp; 131 132 /* clear it (very conservatively) (why so conservatively??) */ 133 VG_(memset)(&frame->lower_guardzone, 0, 512); 134 VG_(memset)(&frame->gst, 0, sizeof(VexGuestAMD64State)); 135 VG_(memset)(&frame->gshadow1, 0, sizeof(VexGuestAMD64State)); 136 VG_(memset)(&frame->gshadow2, 0, sizeof(VexGuestAMD64State)); 137 VG_(memset)(&frame->fake_siginfo, 0, sizeof(frame->fake_siginfo)); 138 VG_(memset)(&frame->fake_ucontext, 0, sizeof(frame->fake_ucontext)); 139 140 /* save stuff in frame */ 141 frame->gst = tst->arch.vex; 142 frame->gshadow1 = tst->arch.vex_shadow1; 143 frame->gshadow2 = tst->arch.vex_shadow2; 144 frame->sigNo_private = sigNo; 145 frame->mask = tst->sig_mask; 146 frame->magicPI = 0x31415927; 147 148 /* Minimally fill in the siginfo and ucontext. Note, utter 149 lameness prevails. Be underwhelmed, be very underwhelmed. */ 150 frame->fake_siginfo.si_signo = sigNo; 151 frame->fake_siginfo.si_code = siginfo->si_code; 152 153 /* Set up stack pointer */ 154 vg_assert(rsp == (Addr)&frame->returnAddr); 155 VG_(set_SP)(tid, rsp); 156 VG_TRACK( post_reg_write, Vg_CoreSignal, tid, VG_O_STACK_PTR, sizeof(ULong)); 157 158 /* Set up program counter */ 159 VG_(set_IP)(tid, (ULong)handler); 160 VG_TRACK( post_reg_write, Vg_CoreSignal, tid, VG_O_INSTR_PTR, sizeof(ULong)); 161 162 /* Set up RA and args for the frame */ 163 VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal handler frame", 164 (Addr)frame, 1*sizeof(ULong) ); 165 frame->returnAddr = (ULong)&VG_(amd64_darwin_SUBST_FOR_sigreturn); 166 167 /* XXX should tell the tool that these regs got written */ 168 tst->arch.vex.guest_RDI = (ULong) sigNo; 169 tst->arch.vex.guest_RSI = (Addr) &frame->fake_siginfo;/* oh well */ 170 tst->arch.vex.guest_RDX = (Addr) &frame->fake_ucontext; /* oh well */ 171 172 VG_TRACK( post_mem_write, Vg_CoreSignal, tid, 173 (Addr)frame, 1*sizeof(ULong) ); 174 VG_TRACK( post_mem_write, Vg_CoreSignal, tid, 175 (Addr)&frame->fake_siginfo, sizeof(frame->fake_siginfo)); 176 VG_TRACK( post_mem_write, Vg_CoreSignal, tid, 177 (Addr)&frame->fake_ucontext, sizeof(frame->fake_ucontext)); 178 179 if (VG_(clo_trace_signals)) 180 VG_(message)(Vg_DebugMsg, 181 "sigframe_create (thread %d): " 182 "next EIP=%#lx, next ESP=%#lx\n", 183 tid, (Addr)handler, (Addr)frame ); 184 } 185 186 187 /* Remove a signal frame from thread 'tid's stack, and restore the CPU 188 state from it. Note, isRT is irrelevant here. */ 189 void VG_(sigframe_destroy)( ThreadId tid, Bool isRT ) 190 { 191 ThreadState *tst; 192 Addr rsp; 193 Int sigNo; 194 struct hacky_sigframe* frame; 195 196 vg_assert(VG_(is_valid_tid)(tid)); 197 tst = VG_(get_ThreadState)(tid); 198 199 /* Check that the stack frame looks valid */ 200 rsp = VG_(get_SP)(tid); 201 202 /* why -8 ? because the signal handler's return will have popped 203 the return address off the stack; and the return address is the 204 lowest-addressed element of hacky_sigframe. */ 205 frame = (struct hacky_sigframe*)(rsp - 8); 206 vg_assert(frame->magicPI == 0x31415927); 207 208 /* This +8 is because of the -8 referred to in the ELF ABI comment 209 in VG_(sigframe_create) just above. */ 210 vg_assert(VG_IS_16_ALIGNED((Addr)frame + 8)); 211 212 /* restore the entire guest state, and shadows, from the 213 frame. Note, as per comments above, this is a kludge - should 214 restore it from saved ucontext. Oh well. */ 215 tst->arch.vex = frame->gst; 216 tst->arch.vex_shadow1 = frame->gshadow1; 217 tst->arch.vex_shadow2 = frame->gshadow2; 218 tst->sig_mask = frame->mask; 219 tst->tmp_sig_mask = frame->mask; 220 sigNo = frame->sigNo_private; 221 222 if (VG_(clo_trace_signals)) 223 VG_(message)(Vg_DebugMsg, 224 "sigframe_destroy (thread %d): " 225 "valid magic; next RIP=%#llx\n", 226 tid, tst->arch.vex.guest_RIP); 227 228 VG_TRACK( die_mem_stack_signal, 229 (Addr)frame - VG_STACK_REDZONE_SZB, 230 sizeof(struct hacky_sigframe) ); 231 232 /* tell the tools */ 233 VG_TRACK( post_deliver_signal, tid, sigNo ); 234 } 235 236 #endif // defined(VGP_amd64_darwin) 237 238 /*--------------------------------------------------------------------*/ 239 /*--- end sigframe-amd64-darwin.c ---*/ 240 /*--------------------------------------------------------------------*/ 241
