1
2 /*--------------------------------------------------------------------*/
3 /*--- Create/destroy signal delivery frames. ---*/
4 /*--- sigframe-ppc64-linux.c ---*/
5 /*--------------------------------------------------------------------*/
6
7 /*
8 This file is part of Valgrind, a dynamic binary instrumentation
9 framework.
10
11 Copyright (C) 2000-2012 Nicholas Nethercote
12 njn@valgrind.org
13 Copyright (C) 2004-2012 Paul Mackerras
14 paulus@samba.org
15
16 This program is free software; you can redistribute it and/or
17 modify it under the terms of the GNU General Public License as
18 published by the Free Software Foundation; either version 2 of the
19 License, or (at your option) any later version.
20
21 This program is distributed in the hope that it will be useful, but
22 WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 General Public License for more details.
25
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
29 02111-1307, USA.
30
31 The GNU General Public License is contained in the file COPYING.
32 */
33
34 #if defined(VGP_ppc64_linux)
35
36 #include "pub_core_basics.h"
37 #include "pub_core_vki.h"
38 #include "pub_core_vkiscnums.h"
39 #include "pub_core_libcsetjmp.h" // to keep _threadstate.h happy
40 #include "pub_core_threadstate.h"
41 #include "pub_core_aspacemgr.h"
42 #include "pub_core_libcbase.h"
43 #include "pub_core_libcassert.h"
44 #include "pub_core_libcprint.h"
45 #include "pub_core_machine.h"
46 #include "pub_core_options.h"
47 #include "pub_core_sigframe.h"
48 #include "pub_core_signals.h"
49 #include "pub_core_tooliface.h"
50 #include "pub_core_trampoline.h"
51 #include "pub_core_transtab.h" // VG_(discard_translations)
52
53
54 /* This module creates and removes signal frames for signal deliveries
55 on ppc64-linux.
56
57 Note, this file contains kernel-specific knowledge in the form of
58 'struct sigframe' and 'struct rt_sigframe'. How does that relate
59 to the vki kernel interface stuff?
60
61 Either a 'struct sigframe' or a 'struct rtsigframe' is pushed
62 onto the client's stack. This contains a subsidiary
63 vki_ucontext. That holds the vcpu's state across the signal,
64 so that the sighandler can mess with the vcpu state if it
65 really wants.
66
67 FIXME: sigcontexting is basically broken for the moment. When
68 delivering a signal, the integer registers and %eflags are
69 correctly written into the sigcontext, however the FP and SSE state
70 is not. When returning from a signal, only the integer registers
71 are restored from the sigcontext; the rest of the CPU state is
72 restored to what it was before the signal.
73
74 This will be fixed.
75 */
76
77
78 /*------------------------------------------------------------*/
79 /*--- Signal frame layouts ---*/
80 /*------------------------------------------------------------*/
81
82 // A structure in which to save the application's registers
83 // during the execution of signal handlers.
84
85 // On ppc64-linux, rt_sigframe is used for all signals.
86
87 // In theory, so long as we get the arguments to the handler function
88 // right, it doesn't matter what the exact layout of the rest of the
89 // frame is. Unfortunately, things like gcc's exception unwinding
90 // make assumptions about the locations of various parts of the frame,
91 // so we need to duplicate it exactly.
92
93 /* Many of these byzantine details derived from
94 linux-2.6.13/arch/ppc64/kernel/signal.c */
95
96 #define TRAMP_SIZE 6 /* who knows why - it only needs to be 2. */
97
98 /* Structure containing bits of information that we want to save
99 on signal delivery. */
100 struct vg_sig_private {
101 UInt magicPI;
102 UInt sigNo_private;
103 ULong _unused; /* makes the struct size be zero % 16 */
104 VexGuestPPC64State vex_shadow1;
105 VexGuestPPC64State vex_shadow2;
106 };
107
108 /* Structure put on stack for all signal handlers. */
109 struct rt_sigframe {
110 struct vki_ucontext uc;
111 ULong _unused[2];
112 UInt tramp[TRAMP_SIZE];
113 struct vki_siginfo* pinfo;
114 void* puc;
115 vki_siginfo_t info;
116 struct vg_sig_private priv;
117 UChar abigap[288];
118 };
119
120 #define SET_SIGNAL_LR(zztst, zzval) \
121 do { tst->arch.vex.guest_LR = (zzval); \
122 VG_TRACK( post_reg_write, Vg_CoreSignal, tst->tid, \
123 offsetof(VexGuestPPC64State,guest_LR), \
124 sizeof(UWord) ); \
125 } while (0)
126
127 #define SET_SIGNAL_GPR(zztst, zzn, zzval) \
128 do { tst->arch.vex.guest_GPR##zzn = (zzval); \
129 VG_TRACK( post_reg_write, Vg_CoreSignal, tst->tid, \
130 offsetof(VexGuestPPC64State,guest_GPR##zzn), \
131 sizeof(UWord) ); \
132 } while (0)
133
134
135 /* Extend the stack segment downwards if needed so as to ensure the
136 new signal frames are mapped to something. Return a Bool
137 indicating whether or not the operation was successful.
138 */
extend(ThreadState * tst,Addr addr,SizeT size)139 static Bool extend ( ThreadState *tst, Addr addr, SizeT size )
140 {
141 ThreadId tid = tst->tid;
142 NSegment const* stackseg = NULL;
143
144 if (VG_(extend_stack)(addr, tst->client_stack_szB)) {
145 stackseg = VG_(am_find_nsegment)(addr);
146 if (0 && stackseg)
147 VG_(printf)("frame=%#lx seg=%#lx-%#lx\n",
148 addr, stackseg->start, stackseg->end);
149 }
150
151 if (stackseg == NULL || !stackseg->hasR || !stackseg->hasW) {
152 VG_(message)(
153 Vg_UserMsg,
154 "Can't extend stack to %#lx during signal delivery for thread %d:\n",
155 addr, tid);
156 if (stackseg == NULL)
157 VG_(message)(Vg_UserMsg, " no stack segment\n");
158 else
159 VG_(message)(Vg_UserMsg, " too small or bad protection modes\n");
160
161 /* set SIGSEGV to default handler */
162 VG_(set_default_handler)(VKI_SIGSEGV);
163 VG_(synth_fault_mapping)(tid, addr);
164
165 /* The whole process should be about to die, since the default
166 action of SIGSEGV to kill the whole process. */
167 return False;
168 }
169
170 /* For tracking memory events, indicate the entire frame has been
171 allocated. */
172 VG_TRACK( new_mem_stack_signal, addr - VG_STACK_REDZONE_SZB,
173 size + VG_STACK_REDZONE_SZB, tid );
174
175 return True;
176 }
177
178
179 /* EXPORTED */
VG_(sigframe_create)180 void VG_(sigframe_create)( ThreadId tid,
181 Addr sp_top_of_frame,
182 const vki_siginfo_t *siginfo,
183 const struct vki_ucontext *siguc,
184 void *handler,
185 UInt flags,
186 const vki_sigset_t *mask,
187 void *restorer )
188 {
189 struct vg_sig_private* priv;
190 Addr sp;
191 ThreadState* tst;
192 Int sigNo = siginfo->si_signo;
193 /* Addr faultaddr; */ /* UNUSED */
194 struct rt_sigframe* frame;
195
196 /* Stack must be 16-byte aligned */
197 vg_assert(VG_IS_16_ALIGNED(sizeof(struct vg_sig_private)));
198 vg_assert(VG_IS_16_ALIGNED(sizeof(struct rt_sigframe)));
199
200 sp_top_of_frame &= ~0xf;
201 sp = sp_top_of_frame - sizeof(struct rt_sigframe);
202
203 tst = VG_(get_ThreadState)(tid);
204 if (!extend(tst, sp, sp_top_of_frame - sp))
205 return;
206
207 vg_assert(VG_IS_16_ALIGNED(sp));
208
209 frame = (struct rt_sigframe *) sp;
210
211 /* clear it (conservatively) */
212 VG_(memset)(frame, 0, sizeof(*frame));
213
214 /////////
215 frame->pinfo = &frame->info;
216 frame->puc = &frame->uc;
217
218 frame->uc.uc_flags = 0;
219 frame->uc.uc_link = 0;
220 /////////
221
222 /* Set up the stack chain pointer */
223 VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal handler frame",
224 sp, sizeof(UWord) );
225 *(Addr *)sp = tst->arch.vex.guest_GPR1;
226 VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
227 sp, sizeof(UWord) );
228
229 /* UNUSED:
230 faultaddr = (Addr)siginfo->_sifields._sigfault._addr;
231 if (sigNo == VKI_SIGILL && siginfo->si_code > 0)
232 faultaddr = tst->arch.vex.guest_CIA;
233 */
234
235 VG_(memcpy)(&frame->info, siginfo, sizeof(*siginfo));
236 VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
237 (Addr)&frame->info, sizeof(frame->info) );
238
239 frame->uc.uc_flags = 0;
240 frame->uc.uc_link = 0;
241 frame->uc.uc_stack = tst->altstack;
242 frame->uc.uc_sigmask = tst->sig_mask;
243 VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
244 (Addr)(&frame->uc), sizeof(frame->uc) );
245
246 # define DO(gpr) frame->uc.uc_mcontext.gp_regs[VKI_PT_R0+gpr] \
247 = tst->arch.vex.guest_GPR##gpr
248 DO(0); DO(1); DO(2); DO(3); DO(4); DO(5); DO(6); DO(7);
249 DO(8); DO(9); DO(10); DO(11); DO(12); DO(13); DO(14); DO(15);
250 DO(16); DO(17); DO(18); DO(19); DO(20); DO(21); DO(22); DO(23);
251 DO(24); DO(25); DO(26); DO(27); DO(28); DO(29); DO(30); DO(31);
252 # undef DO
253
254 frame->uc.uc_mcontext.gp_regs[VKI_PT_NIP] = tst->arch.vex.guest_CIA;
255 frame->uc.uc_mcontext.gp_regs[VKI_PT_MSR] = 0xf032; /* pretty arbitrary */
256 frame->uc.uc_mcontext.gp_regs[VKI_PT_ORIG_R3] = tst->arch.vex.guest_GPR3;
257 frame->uc.uc_mcontext.gp_regs[VKI_PT_CTR] = tst->arch.vex.guest_CTR;
258 frame->uc.uc_mcontext.gp_regs[VKI_PT_LNK] = tst->arch.vex.guest_LR;
259 frame->uc.uc_mcontext.gp_regs[VKI_PT_XER] = LibVEX_GuestPPC64_get_XER(
260 &tst->arch.vex);
261 frame->uc.uc_mcontext.gp_regs[VKI_PT_CCR] = LibVEX_GuestPPC64_get_CR(
262 &tst->arch.vex);
263 //mc->mc_gregs[VKI_PT_MQ] = 0;
264 //mc->mc_gregs[VKI_PT_TRAP] = 0;
265 //mc->mc_gregs[VKI_PT_DAR] = fault_addr;
266 //mc->mc_gregs[VKI_PT_DSISR] = 0;
267 //mc->mc_gregs[VKI_PT_RESULT] = 0;
268
269 /* XXX should do FP and vector regs */
270
271 /* set up signal return trampoline */
272 /* NB. 5 Sept 07. mc->mc_pad[0..1] used to contain a the code to
273 which the signal handler returns, and it just did sys_sigreturn
274 or sys_rt_sigreturn. But this doesn't work if the stack is
275 non-executable, and it isn't consistent with the x86-linux and
276 amd64-linux scheme for removing the stack frame. So instead be
277 consistent and use a stub in m_trampoline. Then it doesn't
278 matter whether or not the (guest) stack is executable. This
279 fixes #149519 and #145837. */
280 frame->tramp[0] = 0; /* invalid */
281 frame->tramp[1] = 0; /* invalid */
282 VG_TRACK(post_mem_write, Vg_CoreSignal, tst->tid,
283 (Addr)&frame->tramp, sizeof(frame->tramp));
284
285 /* invalidate any translation of this area */
286 VG_(discard_translations)( (Addr64)&frame->tramp[0],
287 sizeof(frame->tramp), "stack_mcontext" );
288
289 /* set the signal handler to return to the trampoline */
290 SET_SIGNAL_LR(tst, (Addr)&VG_(ppc64_linux_SUBST_FOR_rt_sigreturn));
291
292 /* Stack pointer for the handler .. (note, back chain set
293 earlier) */
294 SET_SIGNAL_GPR(tid, 1, sp);
295
296 /* Args for the handler .. */
297 SET_SIGNAL_GPR(tid, 3, sigNo);
298 SET_SIGNAL_GPR(tid, 4, (Addr) &frame->info);
299 SET_SIGNAL_GPR(tid, 5, (Addr) &frame->uc);
300 /* the kernel sets this, though it doesn't seem to be in the ABI */
301 SET_SIGNAL_GPR(tid, 6, (Addr) &frame->info);
302
303 /* Handler is in fact a standard ppc64-linux function descriptor,
304 so extract the function entry point and also the toc ptr to use. */
305 SET_SIGNAL_GPR(tid, 2, (Addr) ((ULong*)handler)[1]);
306 tst->arch.vex.guest_CIA = (Addr) ((ULong*)handler)[0];
307
308 priv = &frame->priv;
309 priv->magicPI = 0x31415927;
310 priv->sigNo_private = sigNo;
311 priv->vex_shadow1 = tst->arch.vex_shadow1;
312 priv->vex_shadow2 = tst->arch.vex_shadow2;
313
314 if (0)
315 VG_(printf)("pushed signal frame; %%R1 now = %#lx, "
316 "next %%CIA = %#llx, status=%d\n",
317 sp, tst->arch.vex.guest_CIA, tst->status);
318 }
319
320
321 /*------------------------------------------------------------*/
322 /*--- Destroying signal frames ---*/
323 /*------------------------------------------------------------*/
324
325 /* EXPORTED */
VG_(sigframe_destroy)326 void VG_(sigframe_destroy)( ThreadId tid, Bool isRT )
327 {
328 ThreadState *tst;
329 struct vg_sig_private *priv;
330 Addr sp;
331 UInt frame_size;
332 struct rt_sigframe *frame;
333 Int sigNo;
334 Bool has_siginfo = isRT;
335
336 vg_assert(VG_(is_valid_tid)(tid));
337 tst = VG_(get_ThreadState)(tid);
338
339 /* Check that the stack frame looks valid */
340 sp = tst->arch.vex.guest_GPR1;
341 vg_assert(VG_IS_16_ALIGNED(sp));
342 /* JRS 17 Nov 05: This code used to check that *sp -- which should
343 have been set by the stwu at the start of the handler -- points
344 to just above the frame (ie, the previous frame). However, that
345 isn't valid when delivering signals on alt stacks. So I removed
346 it. The frame is still sanity-checked using the priv->magicPI
347 field. */
348
349 frame = (struct rt_sigframe *)sp;
350 frame_size = sizeof(*frame);
351 priv = &frame->priv;
352 vg_assert(priv->magicPI == 0x31415927);
353 tst->sig_mask = frame->uc.uc_sigmask;
354 tst->tmp_sig_mask = tst->sig_mask;
355
356 sigNo = priv->sigNo_private;
357
358 # define DO(gpr) tst->arch.vex.guest_GPR##gpr \
359 = frame->uc.uc_mcontext.gp_regs[VKI_PT_R0+gpr]
360 DO(0); DO(1); DO(2); DO(3); DO(4); DO(5); DO(6); DO(7);
361 DO(8); DO(9); DO(10); DO(11); DO(12); DO(13); DO(14); DO(15);
362 DO(16); DO(17); DO(18); DO(19); DO(20); DO(21); DO(22); DO(23);
363 DO(24); DO(25); DO(26); DO(27); DO(28); DO(29); DO(30); DO(31);
364 # undef DO
365
366 tst->arch.vex.guest_CIA = frame->uc.uc_mcontext.gp_regs[VKI_PT_NIP];
367
368 LibVEX_GuestPPC64_put_CR( frame->uc.uc_mcontext.gp_regs[VKI_PT_CCR],
369 &tst->arch.vex );
370
371 tst->arch.vex.guest_LR = frame->uc.uc_mcontext.gp_regs[VKI_PT_LNK];
372 tst->arch.vex.guest_CTR = frame->uc.uc_mcontext.gp_regs[VKI_PT_CTR];
373 LibVEX_GuestPPC64_put_XER( frame->uc.uc_mcontext.gp_regs[VKI_PT_XER],
374 &tst->arch.vex );
375
376 tst->arch.vex_shadow1 = priv->vex_shadow1;
377 tst->arch.vex_shadow2 = priv->vex_shadow2;
378
379 VG_TRACK(die_mem_stack_signal, sp, frame_size);
380
381 if (VG_(clo_trace_signals))
382 VG_(message)(Vg_DebugMsg,
383 "vg_pop_signal_frame (thread %d): isRT=%d "
384 "valid magic; EIP=%#llx\n",
385 tid, has_siginfo, tst->arch.vex.guest_CIA);
386
387 /* tell the tools */
388 VG_TRACK( post_deliver_signal, tid, sigNo );
389 }
390
391 #endif // defined(VGP_ppc64_linux)
392
393 /*--------------------------------------------------------------------*/
394 /*--- end ---*/
395 /*--------------------------------------------------------------------*/
396