l4/pkg/valgrind/src/valgrind-3.6.0-svn/coregrind/m_sigframe/sigframe-x86-darwin.c

   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-2010 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 */
  66 struct 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 */
  92 static 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). */
 112 void 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. */
 192 void 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 /*--------------------------------------------------------------------*/