/*--------------------------------------------------------------------*/ /*--- Create/destroy signal delivery frames. ---*/ /*--- sigframe-solaris.c ---*/ /*--------------------------------------------------------------------*/ /* This file is part of Valgrind, a dynamic binary instrumentation framework. Copyright (C) 2011-2017 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//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 ---*/ /*--------------------------------------------------------------------*/