| |
| /*--------------------------------------------------------------------*/ |
| /*--- Create/destroy signal delivery frames. ---*/ |
| /*--- sigframe-solaris.c ---*/ |
| /*--------------------------------------------------------------------*/ |
| |
| /* |
| This file is part of Valgrind, a dynamic binary instrumentation |
| framework. |
| |
| Copyright (C) 2011-2015 Petr Pavlu |
| setup@dagobah.cz |
| |
| 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_x86_solaris) || defined(VGP_amd64_solaris) |
| |
| #include "pub_core_basics.h" |
| #include "pub_core_vki.h" |
| #include "pub_core_threadstate.h" |
| #include "pub_core_aspacemgr.h" |
| #include "pub_core_libcassert.h" |
| #include "pub_core_libcbase.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_sigframe.h" /* Self */ |
| #include "pub_core_syswrap.h" |
| #include "priv_sigframe.h" |
| |
| /* This module creates and removes signal frames for signal deliveries |
| on x86/amd64-solaris. */ |
| |
| /* 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 x86/amd64 calling |
| conventions will simply cause the extra 2 args to be ignored (inside the |
| handler). */ |
| 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 = VG_(get_ThreadState)(tid); |
| Addr esp; |
| vki_sigframe_t *frame; |
| Int signo = siginfo->si_signo; |
| |
| /* Calculate new stack pointer. */ |
| esp = sp_top_of_frame - sizeof(vki_sigframe_t); |
| esp = VG_ROUNDDN(esp, 16) - sizeof(UWord); |
| |
| if (!ML_(sf_maybe_extend_stack)(tst, esp, sp_top_of_frame - esp, flags)) |
| return; |
| |
| /* Fill in the frame. */ |
| frame = (vki_sigframe_t*)esp; |
| |
| /* Set a bogus return address. This return address should be never used |
| because to return from a signal handler a program has to call |
| setcontext() explicitly. */ |
| frame->return_addr = (void*)~0UL; |
| |
| /* Save current context. (This has to be done before the thread state is |
| modified in any way.) */ |
| VG_(save_context)(tid, &frame->ucontext, Vg_CoreSignal); |
| |
| /* Fill in the siginfo. */ |
| frame->siginfo = *siginfo; |
| /* Set expected si_addr value. |
| |
| Manual page siginfo.h(3HEAD) describes that some signals define si_addr |
| to be an address of the faulting instruction (SIGILL). Then it is needed |
| to change the real CPU address to the VCPU address. Some signals define |
| si_addr to be an address of the faulting memory reference (SIGSEGV, |
| SIGBUS). Then the address should be passed unmodified. |
| |
| However documentation contained in the manpage does not reflect the |
| reality found in the Solaris kernel - uts/<arch>/os/trap.c. Here one can |
| observe that in some cases si_addr is set to address provided by the |
| underlying subsystem. In some cases si_addr is set to the current |
| program counter. Other signals are missing documentation altogether. |
| It is almost impossible to determine what value is stored in si_addr |
| based on the information provided by kernel to the signal handler. |
| |
| POSIX.1-2008 says about si_addr: |
| SIGILL, SIGFPE ... Address of faulting instruction. |
| SIGSEGV, SIGBUS ... Address of faulting memory reference. |
| For some implementations, the value of si_addr may be inaccurate. |
| |
| See tests none/tests/faultstatus and none/tests/x86/badseg for examples. |
| The code below simply follows the POSIX standard, but propagates any |
| possibly incorrect values from the kernel to the user. |
| */ |
| switch (signo) { |
| case VKI_SIGSEGV: |
| switch (siginfo->si_code) { |
| case VKI_SEGV_ACCERR: |
| case VKI_SEGV_MAPERR: |
| default: |
| break; |
| case VKI_SEGV_MADE_UP_GPF: |
| /* Translate si_code synthesized by Valgrind to SEGV_MAPPER. */ |
| frame->siginfo.si_code = VKI_SEGV_MAPERR; |
| break; |
| } |
| break; |
| case VKI_SIGBUS: |
| break; |
| case VKI_SIGFPE: |
| case VKI_SIGILL: |
| case VKI_SIGTRAP: |
| frame->siginfo.si_addr = (void*)VG_(get_IP)(tid); |
| break; |
| case VKI_SIGPROF: |
| frame->siginfo.si_faddr = (void*)VG_(get_IP)(tid); |
| break; |
| default: |
| break; |
| } |
| VG_TRACK(post_mem_write, Vg_CoreSignal, tid, (Addr)&frame->siginfo, |
| sizeof(frame->siginfo)); |
| |
| /* Save the signal number in an unused slot. Later, when a return from the |
| signal is made, this value is used to inform the tool that the |
| processing for the given signal has ended. */ |
| VKI_UC_SIGNO(&frame->ucontext) = signo | ((~(UWord)signo & 0xFFFF) << 16); |
| /* Old context has to point to the saved ucontext. */ |
| tst->os_state.oldcontext = &frame->ucontext; |
| /* Save ERR and TRAPNO if siguc is present. */ |
| if (siguc) { |
| frame->ucontext.uc_mcontext.gregs[VKI_REG_ERR] |
| = siguc->uc_mcontext.gregs[VKI_REG_ERR]; |
| VG_TRACK(post_mem_write, Vg_CoreSignal, tid, |
| (Addr)&frame->ucontext.uc_mcontext.gregs[VKI_REG_ERR], |
| sizeof(UWord)); |
| frame->ucontext.uc_mcontext.gregs[VKI_REG_TRAPNO] |
| = siguc->uc_mcontext.gregs[VKI_REG_TRAPNO]; |
| VG_TRACK(post_mem_write, Vg_CoreSignal, tid, |
| (Addr)&frame->ucontext.uc_mcontext.gregs[VKI_REG_TRAPNO], |
| sizeof(UWord)); |
| } |
| |
| /* Prepare parameters for a signal handler. */ |
| frame->a1_signo = signo; |
| /* The first parameter has to be 16-byte aligned, resembling function |
| calls. */ |
| { |
| /* Using |
| vg_assert(VG_IS_16_ALIGNED(&frame->a1_signo)); |
| seems to get miscompiled on amd64 with GCC 4.7.2. */ |
| Addr signo_addr = (Addr)&frame->a1_signo; |
| vg_assert(VG_IS_16_ALIGNED(signo_addr)); |
| } |
| frame->a2_siginfo = &frame->siginfo; |
| VG_TRACK(post_mem_write, Vg_CoreSignal, tid, (Addr)&frame->a1_signo, |
| sizeof(frame->a1_signo) + sizeof(frame->a2_siginfo)); |
| #if defined(VGP_x86_solaris) |
| frame->a3_ucontext = &frame->ucontext; |
| VG_TRACK(post_mem_write, Vg_CoreSignal, tid, (Addr)&frame->a3_ucontext, |
| sizeof(frame->a3_ucontext)); |
| #elif defined(VGP_amd64_solaris) |
| tst->arch.vex.guest_RDI = signo; |
| VG_TRACK(post_reg_write, Vg_CoreSignal, tid, offsetof(VexGuestAMD64State, |
| guest_RDI), sizeof(ULong)); |
| tst->arch.vex.guest_RSI = (Addr)&frame->siginfo; |
| VG_TRACK(post_reg_write, Vg_CoreSignal, tid, offsetof(VexGuestAMD64State, |
| guest_RSI), sizeof(ULong)); |
| tst->arch.vex.guest_RDX = (Addr)&frame->ucontext; |
| VG_TRACK(post_reg_write, Vg_CoreSignal, tid, offsetof(VexGuestAMD64State, |
| guest_RDX), sizeof(ULong)); |
| #endif |
| |
| /* Set up the stack pointer. */ |
| vg_assert(esp == (Addr)&frame->return_addr); |
| VG_(set_SP)(tid, esp); |
| VG_TRACK(post_reg_write, Vg_CoreSignal, tid, VG_O_STACK_PTR, sizeof(Addr)); |
| |
| /* Set up the program counter. Note that we don't inform a tool about IP |
| write because IP is always defined. */ |
| VG_(set_IP)(tid, (Addr)handler); |
| |
| /* If the signal is delivered on the alternate stack, copy it out to |
| ustack. This has to be done after setting a new IP so the SS_ONSTACK |
| flag is set by VG_(do_sys_sigaltstack)(). */ |
| if (on_altstack && tst->os_state.ustack |
| && VG_(am_is_valid_for_client)((Addr)tst->os_state.ustack, |
| sizeof(*tst->os_state.ustack), |
| VKI_PROT_WRITE)) { |
| SysRes res; |
| vki_stack_t altstack; |
| |
| /* Get information about alternate stack. */ |
| res = VG_(do_sys_sigaltstack)(tid, NULL, &altstack); |
| vg_assert(!sr_isError(res)); |
| |
| /* Copy it to ustack. */ |
| *tst->os_state.ustack = altstack; |
| VG_TRACK(post_mem_write, Vg_CoreSignal, tid, (Addr)tst->os_state.ustack, |
| sizeof(*tst->os_state.ustack)); |
| } |
| |
| if (VG_(clo_trace_signals)) |
| VG_(message)(Vg_DebugMsg, |
| "sigframe_create (thread %u): next IP=%#lx, " |
| "next SP=%#lx\n", |
| tid, (Addr)handler, (Addr)frame); |
| } |
| |
| void VG_(sigframe_destroy)(ThreadId tid, Bool isRT) |
| { |
| /* Not used on Solaris. */ |
| vg_assert(0); |
| } |
| |
| void VG_(sigframe_return)(ThreadId tid, const vki_ucontext_t *uc) |
| { |
| Int signo; |
| |
| /* Check if a signal number was saved in the restored context. */ |
| signo = VKI_UC_SIGNO_CONST(uc) & 0xFFFF; |
| if (!signo || signo != ((~VKI_UC_SIGNO_CONST(uc) >> 16) & 0xFFFF)) |
| return; |
| |
| /* Note: The active tool should be informed here about the dead stack area. |
| However, this was already done when the original context was restored (in |
| VG_(restore_context)()) so it is not necessary to do it here again. |
| |
| There is a small nuance though, VG_(restore_context)() triggers the |
| die_mem_stack event while in this case, it should really trigger the |
| die_mem_stack_signal event. This is not currently a problem because all |
| official tools handle these two events in the same way. |
| |
| If a return from an alternate stack is made then no die_mem_stack event |
| is currently triggered. */ |
| |
| /* Returning from a signal handler. */ |
| if (VG_(clo_trace_signals)) |
| VG_(message)(Vg_DebugMsg, |
| "sigframe_return (thread %u): IP=%#lx\n", |
| tid, VG_(get_IP)(tid)); |
| |
| /* Tell the tool. */ |
| VG_TRACK(post_deliver_signal, tid, signo); |
| } |
| |
| #endif // defined(VGP_x86_solaris) || defined(VGP_amd64_solaris) |
| |
| /*--------------------------------------------------------------------*/ |
| /*--- end ---*/ |
| /*--------------------------------------------------------------------*/ |
