• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 
2 /*--------------------------------------------------------------------*/
3 /*--- Create/destroy signal delivery frames.                       ---*/
4 /*---                                  sigframe-mips32-linux.c     ---*/
5 /*--------------------------------------------------------------------*/
6 
7 /*
8    This file is part of Valgrind, a dynamic binary instrumentation
9    framework.
10 
11    Copyright (C) 2010-2017 RT-RK
12       mips-valgrind@rt-rk.com
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_mips32_linux)
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_sigframe.h"
45 #include "pub_core_signals.h"
46 #include "pub_core_tooliface.h"
47 #include "pub_core_trampoline.h"
48 #include "priv_sigframe.h"
49 
50 struct vg_sig_private
51 {
52   UInt magicPI;
53   UInt sigNo_private;
54   VexGuestMIPS32State vex_shadow1;
55   VexGuestMIPS32State vex_shadow2;
56 };
57 
58 struct sigframe
59 {
60   UInt sf_ass[4];       /* argument save space for o32 */
61   UInt sf_pad[2];       /* Was: signal trampoline */
62   struct vki_sigcontext sf_sc;
63   vki_sigset_t sf_mask;
64   struct vg_sig_private priv;
65 };
66 
67 struct rt_sigframe
68 {
69   UInt rs_ass[4];		/* argument save space for o32 */
70   UInt rs_pad[2];		/* Was: signal trampoline */
71   vki_siginfo_t rs_info;
72   struct vki_ucontext rs_uc;
73   struct vg_sig_private priv;
74 };
75 
76 
77 static
setup_sigcontext2(ThreadState * tst,struct vki_sigcontext ** sc1,const vki_siginfo_t * si)78 void setup_sigcontext2 ( ThreadState* tst, struct vki_sigcontext **sc1,
79                          const vki_siginfo_t *si)
80 {
81 
82   struct vki_sigcontext *sc = *sc1;
83 
84   VG_TRACK( pre_mem_write, Vg_CoreSignal, tst->tid, "signal frame mcontext",
85            (Addr)sc, sizeof(unsigned long long)*34 );
86   sc->sc_regs[1] = tst->arch.vex.guest_r1;
87   sc->sc_regs[2] = tst->arch.vex.guest_r2;
88   sc->sc_regs[3] = tst->arch.vex.guest_r3;
89   sc->sc_regs[4] = tst->arch.vex.guest_r4;
90   sc->sc_regs[5] = tst->arch.vex.guest_r5;
91   sc->sc_regs[6] = tst->arch.vex.guest_r6;
92   sc->sc_regs[7] = tst->arch.vex.guest_r7;
93   sc->sc_regs[8] = tst->arch.vex.guest_r8;
94   sc->sc_regs[9] = tst->arch.vex.guest_r9;
95   sc->sc_regs[10] = tst->arch.vex.guest_r10;
96   sc->sc_regs[11] = tst->arch.vex.guest_r11;
97   sc->sc_regs[12] = tst->arch.vex.guest_r12;
98   sc->sc_regs[13] = tst->arch.vex.guest_r13;
99   sc->sc_regs[14] = tst->arch.vex.guest_r14;
100   sc->sc_regs[15] = tst->arch.vex.guest_r15;
101   sc->sc_regs[16] = tst->arch.vex.guest_r16;
102   sc->sc_regs[17] = tst->arch.vex.guest_r17;
103   sc->sc_regs[18] = tst->arch.vex.guest_r18;
104   sc->sc_regs[19] = tst->arch.vex.guest_r19;
105   sc->sc_regs[20] = tst->arch.vex.guest_r20;
106   sc->sc_regs[21] = tst->arch.vex.guest_r21;
107   sc->sc_regs[22] = tst->arch.vex.guest_r22;
108   sc->sc_regs[23] = tst->arch.vex.guest_r23;
109   sc->sc_regs[24] = tst->arch.vex.guest_r24;
110   sc->sc_regs[25] = tst->arch.vex.guest_r25;
111   sc->sc_regs[26] = tst->arch.vex.guest_r26;
112   sc->sc_regs[27] = tst->arch.vex.guest_r27;
113   sc->sc_regs[28] = tst->arch.vex.guest_r28;
114   sc->sc_regs[29] = tst->arch.vex.guest_r29;
115   sc->sc_regs[30] = tst->arch.vex.guest_r30;
116   sc->sc_regs[31] = tst->arch.vex.guest_r31;
117   sc->sc_pc = tst->arch.vex.guest_PC;
118   sc->sc_mdhi = tst->arch.vex.guest_HI;
119   sc->sc_mdlo = tst->arch.vex.guest_LO;
120 }
121 
122 /* EXPORTED */
VG_(sigframe_create)123 void VG_(sigframe_create)( ThreadId tid,
124                            Bool on_altstack,
125                            Addr sp_top_of_frame,
126                            const vki_siginfo_t *siginfo,
127                            const struct vki_ucontext *siguc,
128                            void *handler,
129                            UInt flags,
130                            const vki_sigset_t *mask,
131                            void *restorer )
132 {
133   Addr sp;
134   ThreadState* tst = VG_(get_ThreadState)(tid);
135   Int sigNo = siginfo->si_signo;
136   struct vg_sig_private *priv;
137 
138   /* Stack must be 8-byte aligned */
139   sp_top_of_frame &= ~0xf;
140 
141   if (flags & VKI_SA_SIGINFO)
142     {
143       sp = sp_top_of_frame - sizeof(struct rt_sigframe);
144     }
145   else
146     {
147       sp = sp_top_of_frame - sizeof(struct sigframe);
148     }
149 
150   tst = VG_(get_ThreadState)(tid);
151   if (! ML_(sf_maybe_extend_stack)(tst, sp, sp_top_of_frame - sp, flags))
152     return;
153 
154   vg_assert(VG_IS_8_ALIGNED(sp));
155 
156   if (flags & VKI_SA_SIGINFO)
157     {
158       struct rt_sigframe *frame = (struct rt_sigframe *) sp;
159       struct vki_ucontext *ucp = &frame->rs_uc;
160       if (VG_(clo_trace_signals))
161         VG_(printf)("rt_sigframe\n");
162       /* Create siginfo.  */
163       VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal frame siginfo",
164                (Addr)&frame->rs_info, sizeof(frame->rs_info) );
165 
166       VG_(memcpy)(&frame->rs_info, siginfo, sizeof(*siginfo));
167 
168       VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
169                (Addr)&frame->rs_info, sizeof(frame->rs_info) );
170 
171       /* Create the ucontext.  */
172       VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal frame ucontext",
173                (Addr)ucp, offsetof(struct vki_ucontext, uc_mcontext) );
174 
175       ucp->uc_flags = 0;
176       ucp->uc_link = 0;
177       ucp->uc_stack = tst->altstack;
178 
179       VG_TRACK( post_mem_write, Vg_CoreSignal, tid, (Addr)ucp,
180                offsetof(struct vki_ucontext, uc_mcontext) );
181 
182       struct vki_sigcontext *scp = &(frame->rs_uc.uc_mcontext);
183       setup_sigcontext2(tst, &(scp), siginfo);
184 
185       ucp->uc_sigmask = tst->sig_mask;
186 
187       priv = &frame->priv;
188 
189       /*
190        * Arguments to signal handler:
191        *
192        *   a0 = signal number
193        *   a1 = 0 (should be cause)
194        *   a2 = pointer to ucontext
195        *
196        * $25 and c0_epc point to the signal handler, $29 points to
197        * the struct rt_sigframe.
198        */
199 
200       tst->arch.vex.guest_r4 = siginfo->si_signo;
201       tst->arch.vex.guest_r5 = (Addr) &frame->rs_info;
202       tst->arch.vex.guest_r6 = (Addr) &frame->rs_uc;
203       tst->arch.vex.guest_r29 = (Addr) frame;
204       tst->arch.vex.guest_r25 = (Addr) handler;
205 
206       if (flags & VKI_SA_RESTORER)
207         {
208           tst->arch.vex.guest_r31 = (Addr) restorer;
209         }
210       else
211         {
212           tst->arch.vex.guest_r31 = (Addr)&VG_(mips32_linux_SUBST_FOR_rt_sigreturn);
213         }
214 
215     }
216   else
217     {
218       if (VG_(clo_trace_signals))
219         VG_(printf)("sigframe\n");
220       struct sigframe *frame = (struct sigframe *) sp;
221       struct vki_sigcontext *scp = &(frame->sf_sc);
222       setup_sigcontext2(tst, &(scp), siginfo);
223       frame->sf_mask = tst->sig_mask;
224       priv = &frame->priv;
225       /*
226        * Arguments to signal handler:
227        *
228        *   a0 = signal number
229        *   a1 = 0 (should be cause)
230        *   a2 = pointer to struct sigcontext
231        *
232        * $25 and c0_epc point to the signal handler, $29 points to the
233        * struct sigframe.
234        */
235       tst->arch.vex.guest_r4 = siginfo->si_signo;
236       tst->arch.vex.guest_r5 = 0;
237       tst->arch.vex.guest_r6 = (Addr) &frame->sf_sc;
238       tst->arch.vex.guest_r29 = (Addr) frame;
239       tst->arch.vex.guest_r25 = (Addr) handler;
240 
241       if (flags & VKI_SA_RESTORER)
242         {
243           tst->arch.vex.guest_r31 = (Addr) restorer;
244         }
245       else
246         {
247           tst->arch.vex.guest_r31 = (Addr)&VG_(mips32_linux_SUBST_FOR_sigreturn);
248         }
249     }
250 
251   priv->magicPI       = 0x31415927;
252   priv->sigNo_private = sigNo;
253   priv->vex_shadow1   = tst->arch.vex_shadow1;
254   priv->vex_shadow2   = tst->arch.vex_shadow2;
255   /* Set the thread so it will next run the handler. */
256   /* tst->m_sp  = sp;  also notify the tool we've updated SP */
257   VG_TRACK( post_reg_write, Vg_CoreSignal, tid, VG_O_STACK_PTR, sizeof(Addr));
258   if (VG_(clo_trace_signals))
259     VG_(printf)("handler = %p\n", handler);
260   tst->arch.vex.guest_PC = (Addr) handler;
261   /* This thread needs to be marked runnable, but we leave that the
262      caller to do. */
263 }
264 
265 /* EXPORTED */
VG_(sigframe_destroy)266 void VG_(sigframe_destroy)( ThreadId tid, Bool isRT )
267 {
268   ThreadState *tst;
269   struct vg_sig_private *priv1;
270   Addr sp;
271   UInt frame_size;
272   struct vki_sigcontext *mc;
273   Int sigNo;
274   Bool has_siginfo = isRT;
275 
276   vg_assert(VG_(is_valid_tid)(tid));
277   tst = VG_(get_ThreadState)(tid);
278   sp   = tst->arch.vex.guest_r29;
279   if (has_siginfo)
280     {
281       struct rt_sigframe *frame = (struct rt_sigframe *)sp;
282       struct vki_ucontext *ucp = &frame->rs_uc;
283       frame_size = sizeof(*frame);
284       mc = &ucp->uc_mcontext;
285       priv1 = &frame->priv;
286       vg_assert(priv1->magicPI == 0x31415927);
287       sigNo = priv1->sigNo_private;
288     }
289   else
290     {
291       struct sigframe *frame = (struct sigframe *)sp;
292       frame_size = sizeof(*frame);
293       mc = &(frame->sf_sc);
294       priv1 = &frame->priv;
295       vg_assert(priv1->magicPI == 0x31415927);
296       tst->sig_mask = frame->sf_mask;
297       tst->tmp_sig_mask = tst->sig_mask;
298       sigNo = priv1->sigNo_private;
299     }
300   //restore regs
301   tst->arch.vex.guest_r1 = mc->sc_regs[1];
302   tst->arch.vex.guest_r2 = mc->sc_regs[2];
303   tst->arch.vex.guest_r3 = mc->sc_regs[3];
304   tst->arch.vex.guest_r4 = mc->sc_regs[4];
305   tst->arch.vex.guest_r5 = mc->sc_regs[5];
306   tst->arch.vex.guest_r6 = mc->sc_regs[6];
307   tst->arch.vex.guest_r7 = mc->sc_regs[7];
308   tst->arch.vex.guest_r8 = mc->sc_regs[8];
309   tst->arch.vex.guest_r9 = mc->sc_regs[9];
310   tst->arch.vex.guest_r10 = mc->sc_regs[10];
311   tst->arch.vex.guest_r11 = mc->sc_regs[11];
312   tst->arch.vex.guest_r12 = mc->sc_regs[12];
313   tst->arch.vex.guest_r13= mc->sc_regs[13];
314   tst->arch.vex.guest_r14 = mc->sc_regs[14];
315   tst->arch.vex.guest_r15 = mc->sc_regs[15];
316   tst->arch.vex.guest_r16 = mc->sc_regs[16];
317   tst->arch.vex.guest_r17 = mc->sc_regs[17];
318   tst->arch.vex.guest_r18 = mc->sc_regs[18];
319   tst->arch.vex.guest_r19 = mc->sc_regs[19];
320   tst->arch.vex.guest_r20 = mc->sc_regs[20];
321   tst->arch.vex.guest_r21 = mc->sc_regs[21];
322   tst->arch.vex.guest_r22 = mc->sc_regs[22];
323   tst->arch.vex.guest_r23 = mc->sc_regs[23];
324   tst->arch.vex.guest_r24 = mc->sc_regs[24];
325   tst->arch.vex.guest_r25 = mc->sc_regs[25];
326   tst->arch.vex.guest_r26 = mc->sc_regs[26];
327   tst->arch.vex.guest_r27 = mc->sc_regs[27];
328   tst->arch.vex.guest_r28 = mc->sc_regs[28];
329   tst->arch.vex.guest_r30 = mc->sc_regs[30];
330   tst->arch.vex.guest_PC = mc->sc_pc;
331   tst->arch.vex.guest_r31 = mc->sc_regs[31];
332   tst->arch.vex.guest_r29 = mc->sc_regs[29];
333 
334   tst->arch.vex.guest_HI = mc->sc_mdhi;
335   tst->arch.vex.guest_LO = mc->sc_mdlo;
336   tst->arch.vex_shadow1 = priv1->vex_shadow1;
337   tst->arch.vex_shadow2 = priv1->vex_shadow2;
338 
339   VG_TRACK(die_mem_stack_signal, sp, frame_size);
340   if (VG_(clo_trace_signals))
341     VG_(message)( Vg_DebugMsg,
342          "VG_(signal_return) (thread %u): isRT=%d valid magic; EIP=%#x\n",
343          tid, isRT, tst->arch.vex.guest_PC);
344   /* tell the tools */
345   VG_TRACK( post_deliver_signal, tid, sigNo );
346 }
347 
348 #endif // defined(VGP_mips32_linux)
349 
350 /*--------------------------------------------------------------------*/
351 /*--- end                                  sigframe-mips32-linux.c ---*/
352 /*--------------------------------------------------------------------*/
353