/*--------------------------------------------------------------------*/ /*--- Create/destroy signal delivery frames. ---*/ /*--- sigframe-ppc64-linux.c ---*/ /*--------------------------------------------------------------------*/ /* This file is part of Valgrind, a dynamic binary instrumentation framework. Copyright (C) 2000-2017 Nicholas Nethercote njn@valgrind.org Copyright (C) 2004-2017 Paul Mackerras paulus@samba.org 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_ppc64be_linux) || defined(VGP_ppc64le_linux) #include "pub_core_basics.h" #include "pub_core_vki.h" #include "pub_core_vkiscnums.h" #include "pub_core_threadstate.h" #include "pub_core_aspacemgr.h" #include "pub_core_libcbase.h" #include "pub_core_libcassert.h" #include "pub_core_libcprint.h" #include "pub_core_machine.h" #include "pub_core_options.h" #include "pub_core_sigframe.h" #include "pub_core_signals.h" #include "pub_core_tooliface.h" #include "pub_core_trampoline.h" #include "pub_core_transtab.h" // VG_(discard_translations) #include "priv_sigframe.h" /* This module creates and removes signal frames for signal deliveries on ppc64-linux. Note, this file contains kernel-specific knowledge in the form of 'struct sigframe' and 'struct rt_sigframe'. How does that relate to the vki kernel interface stuff? Either a 'struct sigframe' or a 'struct rtsigframe' is pushed onto the client's stack. This contains a subsidiary vki_ucontext. That holds the vcpu's state across the signal, so that the sighandler can mess with the vcpu state if it really wants. FIXME: sigcontexting is basically broken for the moment. When delivering a signal, the integer registers and %eflags are correctly written into the sigcontext, however the FP and SSE state is not. When returning from a signal, only the integer registers are restored from the sigcontext; the rest of the CPU state is restored to what it was before the signal. This will be fixed. */ /*------------------------------------------------------------*/ /*--- Signal frame layouts ---*/ /*------------------------------------------------------------*/ // A structure in which to save the application's registers // during the execution of signal handlers. // On ppc64-linux, rt_sigframe is used for all signals. // In theory, so long as we get the arguments to the handler function // right, it doesn't matter what the exact layout of the rest of the // frame is. Unfortunately, things like gcc's exception unwinding // make assumptions about the locations of various parts of the frame, // so we need to duplicate it exactly. /* Many of these byzantine details derived from linux-2.6.13/arch/ppc64/kernel/signal.c */ #define TRAMP_SIZE 6 /* who knows why - it only needs to be 2. */ /* Structure containing bits of information that we want to save on signal delivery. */ struct vg_sig_private { UInt magicPI; UInt sigNo_private; ULong _unused; /* makes the struct size be zero % 16 */ VexGuestPPC64State vex_shadow1; VexGuestPPC64State vex_shadow2; }; /* Structure put on stack for all signal handlers. */ struct rt_sigframe { struct vki_ucontext uc; ULong _unused[2]; UInt tramp[TRAMP_SIZE]; struct vki_siginfo* pinfo; void* puc; vki_siginfo_t info; struct vg_sig_private priv; UChar abigap[288]; // unused }; #define SET_SIGNAL_LR(zztst, zzval) \ do { tst->arch.vex.guest_LR = (zzval); \ VG_TRACK( post_reg_write, Vg_CoreSignal, tst->tid, \ offsetof(VexGuestPPC64State,guest_LR), \ sizeof(UWord) ); \ } while (0) #define SET_SIGNAL_GPR(zztst, zzn, zzval) \ do { tst->arch.vex.guest_GPR##zzn = (zzval); \ VG_TRACK( post_reg_write, Vg_CoreSignal, tst->tid, \ offsetof(VexGuestPPC64State,guest_GPR##zzn), \ sizeof(UWord) ); \ } while (0) /* EXPORTED */ 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 ) { struct vg_sig_private* priv; Addr sp; ThreadState* tst; Int sigNo = siginfo->si_signo; /* Addr faultaddr; */ /* UNUSED */ struct rt_sigframe* frame; /* Stack must be 16-byte aligned */ vg_assert(VG_IS_16_ALIGNED(sizeof(struct vg_sig_private))); vg_assert(VG_IS_16_ALIGNED(sizeof(struct rt_sigframe))); sp_top_of_frame &= ~0xf; sp = sp_top_of_frame - sizeof(struct rt_sigframe); tst = VG_(get_ThreadState)(tid); if (! ML_(sf_maybe_extend_stack)(tst, sp, sp_top_of_frame - sp, flags)) return; vg_assert(VG_IS_16_ALIGNED(sp)); frame = (struct rt_sigframe *) sp; /* clear it (conservatively) */ VG_(memset)(frame, 0, sizeof(*frame)); ///////// frame->pinfo = &frame->info; frame->puc = &frame->uc; frame->uc.uc_flags = 0; frame->uc.uc_link = 0; ///////// /* Set up the stack chain pointer */ VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal handler frame", sp, sizeof(UWord) ); *(Addr *)sp = tst->arch.vex.guest_GPR1; VG_TRACK( post_mem_write, Vg_CoreSignal, tid, sp, sizeof(UWord) ); /* UNUSED: faultaddr = (Addr)siginfo->_sifields._sigfault._addr; if (sigNo == VKI_SIGILL && siginfo->si_code > 0) faultaddr = tst->arch.vex.guest_CIA; */ VG_(memcpy)(&frame->info, siginfo, sizeof(*siginfo)); VG_TRACK( post_mem_write, Vg_CoreSignal, tid, (Addr)&frame->info, sizeof(frame->info) ); frame->uc.uc_flags = 0; frame->uc.uc_link = 0; frame->uc.uc_stack = tst->altstack; frame->uc.uc_sigmask = tst->sig_mask; VG_TRACK( post_mem_write, Vg_CoreSignal, tid, (Addr)(&frame->uc), sizeof(frame->uc) ); # define DO(gpr) frame->uc.uc_mcontext.gp_regs[VKI_PT_R0+gpr] \ = tst->arch.vex.guest_GPR##gpr DO(0); DO(1); DO(2); DO(3); DO(4); DO(5); DO(6); DO(7); DO(8); DO(9); DO(10); DO(11); DO(12); DO(13); DO(14); DO(15); DO(16); DO(17); DO(18); DO(19); DO(20); DO(21); DO(22); DO(23); DO(24); DO(25); DO(26); DO(27); DO(28); DO(29); DO(30); DO(31); # undef DO frame->uc.uc_mcontext.gp_regs[VKI_PT_NIP] = tst->arch.vex.guest_CIA; #ifdef VGP_ppc64le_linux frame->uc.uc_mcontext.gp_regs[VKI_PT_MSR] = 0xf033; /* pretty arbitrary */ #else frame->uc.uc_mcontext.gp_regs[VKI_PT_MSR] = 0xf032; /* pretty arbitrary */ #endif frame->uc.uc_mcontext.gp_regs[VKI_PT_ORIG_R3] = tst->arch.vex.guest_GPR3; frame->uc.uc_mcontext.gp_regs[VKI_PT_CTR] = tst->arch.vex.guest_CTR; frame->uc.uc_mcontext.gp_regs[VKI_PT_LNK] = tst->arch.vex.guest_LR; frame->uc.uc_mcontext.gp_regs[VKI_PT_XER] = LibVEX_GuestPPC64_get_XER( &tst->arch.vex); frame->uc.uc_mcontext.gp_regs[VKI_PT_CCR] = LibVEX_GuestPPC64_get_CR( &tst->arch.vex); //mc->mc_gregs[VKI_PT_MQ] = 0; //mc->mc_gregs[VKI_PT_TRAP] = 0; //mc->mc_gregs[VKI_PT_DAR] = fault_addr; //mc->mc_gregs[VKI_PT_DSISR] = 0; //mc->mc_gregs[VKI_PT_RESULT] = 0; /* XXX should do FP and vector regs */ /* set up signal return trampoline */ /* NB. 5 Sept 07. mc->mc_pad[0..1] used to contain a the code to which the signal handler returns, and it just did sys_sigreturn or sys_rt_sigreturn. But this doesn't work if the stack is non-executable, and it isn't consistent with the x86-linux and amd64-linux scheme for removing the stack frame. So instead be consistent and use a stub in m_trampoline. Then it doesn't matter whether or not the (guest) stack is executable. This fixes #149519 and #145837. */ frame->tramp[0] = 0; /* invalid */ frame->tramp[1] = 0; /* invalid */ VG_TRACK(post_mem_write, Vg_CoreSignal, tst->tid, (Addr)&frame->tramp, sizeof(frame->tramp)); /* invalidate any translation of this area */ VG_(discard_translations)( (Addr)&frame->tramp[0], sizeof(frame->tramp), "stack_mcontext" ); /* set the signal handler to return to the trampoline */ SET_SIGNAL_LR(tst, (Addr)&VG_(ppc64_linux_SUBST_FOR_rt_sigreturn)); /* Stack pointer for the handler .. (note, back chain set earlier) */ SET_SIGNAL_GPR(tid, 1, sp); /* Args for the handler .. */ SET_SIGNAL_GPR(tid, 3, sigNo); SET_SIGNAL_GPR(tid, 4, (Addr) &frame->info); SET_SIGNAL_GPR(tid, 5, (Addr) &frame->uc); /* the kernel sets this, though it doesn't seem to be in the ABI */ SET_SIGNAL_GPR(tid, 6, (Addr) &frame->info); /* Handler is in fact a standard ppc64-linux function descriptor, so extract the function entry point and also the toc ptr to use. */ #if defined(VGP_ppc64be_linux) SET_SIGNAL_GPR(tid, 2, (Addr) ((ULong*)handler)[1]); tst->arch.vex.guest_CIA = (Addr) ((ULong*)handler)[0]; #else SET_SIGNAL_GPR(tid, 12, (Addr) handler); tst->arch.vex.guest_CIA = (Addr) handler; #endif priv = &frame->priv; priv->magicPI = 0x31415927; priv->sigNo_private = sigNo; priv->vex_shadow1 = tst->arch.vex_shadow1; priv->vex_shadow2 = tst->arch.vex_shadow2; if (0) VG_(printf)("pushed signal frame; %%R1 now = %#lx, " "next %%CIA = %#llx, status=%d\n", sp, tst->arch.vex.guest_CIA, (Int)tst->status); } /*------------------------------------------------------------*/ /*--- Destroying signal frames ---*/ /*------------------------------------------------------------*/ /* EXPORTED */ void VG_(sigframe_destroy)( ThreadId tid, Bool isRT ) { ThreadState *tst; struct vg_sig_private *priv; Addr sp; UInt frame_size; struct rt_sigframe *frame; Int sigNo; Bool has_siginfo = isRT; vg_assert(VG_(is_valid_tid)(tid)); tst = VG_(get_ThreadState)(tid); /* Check that the stack frame looks valid */ sp = tst->arch.vex.guest_GPR1; vg_assert(VG_IS_16_ALIGNED(sp)); /* JRS 17 Nov 05: This code used to check that *sp -- which should have been set by the stwu at the start of the handler -- points to just above the frame (ie, the previous frame). However, that isn't valid when delivering signals on alt stacks. So I removed it. The frame is still sanity-checked using the priv->magicPI field. */ frame = (struct rt_sigframe *)sp; frame_size = sizeof(*frame); priv = &frame->priv; vg_assert(priv->magicPI == 0x31415927); tst->sig_mask = frame->uc.uc_sigmask; tst->tmp_sig_mask = tst->sig_mask; sigNo = priv->sigNo_private; # define DO(gpr) tst->arch.vex.guest_GPR##gpr \ = frame->uc.uc_mcontext.gp_regs[VKI_PT_R0+gpr] DO(0); DO(1); DO(2); DO(3); DO(4); DO(5); DO(6); DO(7); DO(8); DO(9); DO(10); DO(11); DO(12); DO(13); DO(14); DO(15); DO(16); DO(17); DO(18); DO(19); DO(20); DO(21); DO(22); DO(23); DO(24); DO(25); DO(26); DO(27); DO(28); DO(29); DO(30); DO(31); # undef DO tst->arch.vex.guest_CIA = frame->uc.uc_mcontext.gp_regs[VKI_PT_NIP]; LibVEX_GuestPPC64_put_CR( frame->uc.uc_mcontext.gp_regs[VKI_PT_CCR], &tst->arch.vex ); tst->arch.vex.guest_LR = frame->uc.uc_mcontext.gp_regs[VKI_PT_LNK]; tst->arch.vex.guest_CTR = frame->uc.uc_mcontext.gp_regs[VKI_PT_CTR]; LibVEX_GuestPPC64_put_XER( frame->uc.uc_mcontext.gp_regs[VKI_PT_XER], &tst->arch.vex ); tst->arch.vex_shadow1 = priv->vex_shadow1; tst->arch.vex_shadow2 = priv->vex_shadow2; VG_TRACK(die_mem_stack_signal, sp, frame_size); if (VG_(clo_trace_signals)) VG_(message)(Vg_DebugMsg, "vg_pop_signal_frame (thread %u): isRT=%d " "valid magic; EIP=%#llx\n", tid, has_siginfo, tst->arch.vex.guest_CIA); /* tell the tools */ VG_TRACK( post_deliver_signal, tid, sigNo ); } #endif // defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux) /*--------------------------------------------------------------------*/ /*--- end ---*/ /*--------------------------------------------------------------------*/