1 2/*--------------------------------------------------------------------*/ 3/*--- Create/destroy signal delivery frames. ---*/ 4/*--- sigframe-x86-darwin.c ---*/ 5/*--------------------------------------------------------------------*/ 6 7/* 8 This file is part of Valgrind, a dynamic binary instrumentation 9 framework. 10 11 Copyright (C) 2006-2011 OpenWorks Ltd 12 info@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_x86_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 x86-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*/ 66struct hacky_sigframe { 67 /* first four words look like a call to a 3-arg x86 function */ 68 UInt returnAddr; 69 UInt a1_signo; 70 UInt a2_siginfo; 71 UInt a3_ucontext; 72 UChar lower_guardzone[512]; // put nothing here 73 VexGuestX86State gst; 74 VexGuestX86State gshadow1; 75 VexGuestX86State gshadow2; 76 vki_siginfo_t fake_siginfo; 77 struct vki_ucontext fake_ucontext; 78 UInt magicPI; 79 UInt sigNo_private; 80 vki_sigset_t mask; // saved sigmask; restore when hdlr returns 81 UInt __pad[1]; 82 UChar upper_guardzone[512]; // put nothing here 83 // and don't zero it, since that might overwrite the client's 84 // stack redzone, at least on archs which have one 85}; 86 87 88/* Extend the stack segment downwards if needed so as to ensure the 89 new signal frames are mapped to something. Return a Bool 90 indicating whether or not the operation was successful. 91*/ 92static Bool extend ( ThreadState *tst, Addr addr, SizeT size ) 93{ 94 ThreadId tid = tst->tid; 95 /* For tracking memory events, indicate the entire frame has been 96 allocated. Except, don't mess with the area which 97 overlaps the previous frame's redzone. */ 98 /* XXX is the following call really right? compared with the 99 amd64-linux version, this doesn't appear to handle the redzone 100 in the same way. */ 101 VG_TRACK( new_mem_stack_signal, 102 addr - VG_STACK_REDZONE_SZB, size, tid ); 103 return True; 104} 105 106 107/* Create a signal frame for thread 'tid'. Make a 3-arg frame 108 regardless of whether the client originally requested a 1-arg 109 version (no SA_SIGINFO) or a 3-arg one (SA_SIGINFO) since in the 110 former case, the x86 calling conventions will simply cause the 111 extra 2 args to be ignored (inside the handler). */ 112void VG_(sigframe_create) ( ThreadId tid, 113 Addr sp_top_of_frame, 114 const vki_siginfo_t *siginfo, 115 const struct vki_ucontext *siguc, 116 void *handler, 117 UInt flags, 118 const vki_sigset_t *mask, 119 void *restorer ) 120{ 121 ThreadState* tst; 122 Addr esp; 123 struct hacky_sigframe* frame; 124 Int sigNo = siginfo->si_signo; 125 126 vg_assert(VG_IS_16_ALIGNED(sizeof(struct hacky_sigframe))); 127 128 sp_top_of_frame &= ~0xf; 129 esp = sp_top_of_frame - sizeof(struct hacky_sigframe); 130 131 tst = VG_(get_ThreadState)(tid); 132 if (!extend(tst, esp, sp_top_of_frame - esp)) 133 return; 134 135 vg_assert(VG_IS_16_ALIGNED(esp)); 136 137 frame = (struct hacky_sigframe *) esp; 138 139 /* clear it (very conservatively) (why so conservatively??) */ 140 VG_(memset)(&frame->lower_guardzone, 0, 512); 141 VG_(memset)(&frame->gst, 0, sizeof(VexGuestX86State)); 142 VG_(memset)(&frame->gshadow1, 0, sizeof(VexGuestX86State)); 143 VG_(memset)(&frame->gshadow2, 0, sizeof(VexGuestX86State)); 144 VG_(memset)(&frame->fake_siginfo, 0, sizeof(frame->fake_siginfo)); 145 VG_(memset)(&frame->fake_ucontext, 0, sizeof(frame->fake_ucontext)); 146 147 /* save stuff in frame */ 148 frame->gst = tst->arch.vex; 149 frame->gshadow1 = tst->arch.vex_shadow1; 150 frame->gshadow2 = tst->arch.vex_shadow2; 151 frame->sigNo_private = sigNo; 152 frame->mask = tst->sig_mask; 153 frame->magicPI = 0x31415927; 154 155 /* Minimally fill in the siginfo and ucontext. Note, utter 156 lameness prevails. Be underwhelmed, be very underwhelmed. */ 157 frame->fake_siginfo.si_signo = sigNo; 158 frame->fake_siginfo.si_code = siginfo->si_code; 159 160 /* Set up stack pointer */ 161 vg_assert(esp == (Addr)&frame->returnAddr); 162 VG_(set_SP)(tid, esp); 163 VG_TRACK( post_reg_write, Vg_CoreSignal, tid, VG_O_STACK_PTR, sizeof(UInt)); 164 165 /* Set up program counter */ 166 VG_(set_IP)(tid, (UInt)handler); 167 VG_TRACK( post_reg_write, Vg_CoreSignal, tid, VG_O_INSTR_PTR, sizeof(UInt)); 168 169 /* Set up RA and args for the frame */ 170 VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal handler frame", 171 (Addr)frame, 4*sizeof(UInt) ); 172 frame->returnAddr = (UInt)&VG_(x86_darwin_SUBST_FOR_sigreturn); 173 frame->a1_signo = sigNo; 174 frame->a2_siginfo = (UInt)&frame->fake_siginfo; /* oh well */ 175 frame->a3_ucontext = (UInt)&frame->fake_ucontext; /* oh well */ 176 VG_TRACK( post_mem_write, Vg_CoreSignal, tid, 177 (Addr)frame, 4*sizeof(UInt) ); 178 VG_TRACK( post_mem_write, Vg_CoreSignal, tid, 179 (Addr)&frame->fake_siginfo, sizeof(frame->fake_siginfo)); 180 VG_TRACK( post_mem_write, Vg_CoreSignal, tid, 181 (Addr)&frame->fake_ucontext, sizeof(frame->fake_ucontext)); 182 183 if (VG_(clo_trace_signals)) 184 VG_(message)(Vg_DebugMsg, 185 "sigframe_create (thread %d): next EIP=%#lx, next ESP=%#lx", 186 tid, (Addr)handler, (Addr)frame ); 187} 188 189 190/* Remove a signal frame from thread 'tid's stack, and restore the CPU 191 state from it. Note, isRT is irrelevant here. */ 192void VG_(sigframe_destroy)( ThreadId tid, Bool isRT ) 193{ 194 ThreadState *tst; 195 Addr esp; 196 Int sigNo; 197 struct hacky_sigframe* frame; 198 199 vg_assert(VG_(is_valid_tid)(tid)); 200 tst = VG_(get_ThreadState)(tid); 201 202 /* Check that the stack frame looks valid */ 203 esp = VG_(get_SP)(tid); 204 205 /* why -4 ? because the signal handler's return will have popped 206 the return address of the stack; and the return address is the 207 lowest-addressed element of hacky_sigframe. */ 208 frame = (struct hacky_sigframe*)(esp - 4); 209 vg_assert(frame->magicPI == 0x31415927); 210 vg_assert(VG_IS_16_ALIGNED(frame)); 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): valid magic; next EIP=%#x", 225 tid, tst->arch.vex.guest_EIP); 226 227 VG_TRACK( die_mem_stack_signal, 228 (Addr)frame - VG_STACK_REDZONE_SZB, 229 sizeof(struct hacky_sigframe) ); 230 231 /* tell the tools */ 232 VG_TRACK( post_deliver_signal, tid, sigNo ); 233} 234 235#endif // defined(VGP_x86_darwin) 236 237/*--------------------------------------------------------------------*/ 238/*--- end ---*/ 239/*--------------------------------------------------------------------*/ 240