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_threadstate.h"
  38 #include "pub_core_aspacemgr.h"
  39 #include "pub_core_libcbase.h"
  40 #include "pub_core_libcassert.h"
  41 #include "pub_core_libcprint.h"
  42 #include "pub_core_machine.h"
  43 #include "pub_core_options.h"
  44 #include "pub_core_signals.h"
  45 #include "pub_core_tooliface.h"
  46 #include "pub_core_trampoline.h"
  47 #include "pub_core_sigframe.h"      /* self */
  48
  49
  50 /* Cheap-ass hack copied from ppc32-aix5 code, just to get started.
  51    Produce a frame with layout entirely of our own choosing. */
  52
  53 /* This module creates and removes signal frames for signal deliveries
  54    on x86-darwin.  Kludgey; the machine state ought to be saved in a
  55    ucontext and retrieved from it later, so the handler can modify it
  56    and return.  However .. for now .. just stick the vex guest state
  57    in the frame and snarf it again later.
  58
  59    Also, don't bother with creating siginfo and ucontext in the
  60    handler, although do point them somewhere non-faulting.
  61
  62    Frame should have a 16-aligned size, just in case that turns out to
  63    be important for Darwin.  (be conservative)
  64 */
  65 struct hacky_sigframe {
  66    /* first four words look like a call to a 3-arg x86 function */
  67    UInt             returnAddr;
  68    UInt             a1_signo;
  69    UInt             a2_siginfo;
  70    UInt             a3_ucontext;
  71    UChar            lower_guardzone[512];  // put nothing here
  72    VexGuestX86State gst;
  73    VexGuestX86State gshadow1;
  74    VexGuestX86State gshadow2;
  75    vki_siginfo_t    fake_siginfo;
  76    struct vki_ucontext fake_ucontext;
  77    UInt             magicPI;
  78    UInt             sigNo_private;
  79    vki_sigset_t     mask; // saved sigmask; restore when hdlr returns
  80    UInt             __pad[1];
  81    UChar            upper_guardzone[512]; // put nothing here
  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    /* For tracking memory events, indicate the entire frame has been
  93       allocated.  Except, don't mess with the area which
  94       overlaps the previous frame's redzone. */
  95    /* XXX is the following call really right?  compared with the
  96       amd64-linux version, this doesn't appear to handle the redzone
  97       in the same way. */
  98    VG_TRACK( new_mem_stack_signal,
  99              addr, size - VG_STACK_REDZONE_SZB, tid );
 100    return True;
 101 }
 102
 103
 104 /* Create a signal frame for thread 'tid'.  Make a 3-arg frame
 105    regardless of whether the client originally requested a 1-arg
 106    version (no SA_SIGINFO) or a 3-arg one (SA_SIGINFO) since in the
 107    former case, the x86 calling conventions will simply cause the
 108    extra 2 args to be ignored (inside the handler). */
 109 void VG_(sigframe_create) ( ThreadId tid,
 110                             Addr sp_top_of_frame,
 111                             const vki_siginfo_t *siginfo,
 112                             const struct vki_ucontext *siguc,
 113                             void *handler,
 114                             UInt flags,
 115                             const vki_sigset_t *mask,
 116                             void *restorer )
 117 {
 118    ThreadState* tst;
 119    Addr esp;
 120    struct hacky_sigframe* frame;
 121    Int sigNo = siginfo->si_signo;
 122
 123    vg_assert(VG_IS_16_ALIGNED(sizeof(struct hacky_sigframe)));
 124
 125    sp_top_of_frame &= ~0xf;
 126    esp = sp_top_of_frame - sizeof(struct hacky_sigframe);
 127
 128    tst = VG_(get_ThreadState)(tid);
 129    if (!extend(tst, esp, sp_top_of_frame - esp))
 130       return;
 131
 132    vg_assert(VG_IS_16_ALIGNED(esp));
 133
 134    frame = (struct hacky_sigframe *) esp;
 135
 136    /* clear it (very conservatively) (why so conservatively??) */
 137    VG_(memset)(&frame->lower_guardzone, 0, 512);
 138    VG_(memset)(&frame->gst,      0, sizeof(VexGuestX86State));
 139    VG_(memset)(&frame->gshadow1, 0, sizeof(VexGuestX86State));
 140    VG_(memset)(&frame->gshadow2, 0, sizeof(VexGuestX86State));
 141    VG_(memset)(&frame->fake_siginfo,  0, sizeof(frame->fake_siginfo));
 142    VG_(memset)(&frame->fake_ucontext, 0, sizeof(frame->fake_ucontext));
 143
 144    /* save stuff in frame */
 145    frame->gst           = tst->arch.vex;
 146    frame->gshadow1      = tst->arch.vex_shadow1;
 147    frame->gshadow2      = tst->arch.vex_shadow2;
 148    frame->sigNo_private = sigNo;
 149    frame->mask          = tst->sig_mask;
 150    frame->magicPI       = 0x31415927;
 151
 152    /* Minimally fill in the siginfo and ucontext.  Note, utter
 153       lameness prevails.  Be underwhelmed, be very underwhelmed. */
 154    frame->fake_siginfo.si_signo = sigNo;
 155    frame->fake_siginfo.si_code  = siginfo->si_code;
 156
 157    /* Set up stack pointer */
 158    vg_assert(esp == (Addr)&frame->returnAddr);
 159    VG_(set_SP)(tid, esp);
 160    VG_TRACK( post_reg_write, Vg_CoreSignal, tid, VG_O_STACK_PTR, sizeof(UInt));
 161
 162    /* Set up program counter */
 163    VG_(set_IP)(tid, (UInt)handler);
 164    VG_TRACK( post_reg_write, Vg_CoreSignal, tid, VG_O_INSTR_PTR, sizeof(UInt));
 165
 166    /* Set up RA and args for the frame */
 167    VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal handler frame",
 168              (Addr)frame, 4*sizeof(UInt) );
 169    frame->returnAddr  = (UInt)&VG_(x86_darwin_SUBST_FOR_sigreturn);
 170    frame->a1_signo    = sigNo;
 171    frame->a2_siginfo  = (UInt)&frame->fake_siginfo;  /* oh well */
 172    frame->a3_ucontext = (UInt)&frame->fake_ucontext; /* oh well */
 173    VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
 174              (Addr)frame, 4*sizeof(UInt) );
 175    VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
 176              (Addr)&frame->fake_siginfo, sizeof(frame->fake_siginfo));
 177    VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
 178              (Addr)&frame->fake_ucontext, sizeof(frame->fake_ucontext));
 179
 180    if (VG_(clo_trace_signals))
 181       VG_(message)(Vg_DebugMsg,
 182                    "sigframe_create (thread %d): next EIP=%#lx, next ESP=%#lx",
 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 esp;
 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    esp = VG_(get_SP)(tid);
 201
 202    /* why -4 ? because the signal handler's return will have popped
 203       the return address of the stack; and the return address is the
 204       lowest-addressed element of hacky_sigframe. */
 205    frame = (struct hacky_sigframe*)(esp - 4);
 206    vg_assert(frame->magicPI == 0x31415927);
 207    vg_assert(VG_IS_16_ALIGNED(frame));
 208
 209    /* restore the entire guest state, and shadows, from the
 210       frame.  Note, as per comments above, this is a kludge - should
 211       restore it from saved ucontext.  Oh well. */
 212    tst->arch.vex = frame->gst;
 213    tst->arch.vex_shadow1 = frame->gshadow1;
 214    tst->arch.vex_shadow2 = frame->gshadow2;
 215    tst->sig_mask = frame->mask;
 216    tst->tmp_sig_mask = frame->mask;
 217    sigNo = frame->sigNo_private;
 218
 219    if (VG_(clo_trace_signals))
 220       VG_(message)(Vg_DebugMsg,
 221                    "sigframe_destroy (thread %d): valid magic; next EIP=%#x",
 222                    tid, tst->arch.vex.guest_EIP);
 223
 224    VG_TRACK( die_mem_stack_signal,
 225              (Addr)frame,
 226              sizeof(struct hacky_sigframe) - VG_STACK_REDZONE_SZB );
 227
 228    /* tell the tools */
 229    VG_TRACK( post_deliver_signal, tid, sigNo );
 230 }
 231
 232 #endif // defined(VGP_x86_darwin)
 233
 234 /*--------------------------------------------------------------------*/
 235 /*--- end                                                          ---*/
 236 /*--------------------------------------------------------------------*/