1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include "qemu/osdep.h"
20#include "qemu.h"
21#include "user-internals.h"
22#include "signal-common.h"
23#include "linux-user/trace.h"
24
25
26
27
28
29
30
31struct target_sigcontext {
32 target_ulong oldmask;
33
34
35 target_ulong sc_gregs[16];
36 target_ulong sc_pc;
37 target_ulong sc_pr;
38 target_ulong sc_sr;
39 target_ulong sc_gbr;
40 target_ulong sc_mach;
41 target_ulong sc_macl;
42
43
44 target_ulong sc_fpregs[16];
45 target_ulong sc_xfpregs[16];
46 unsigned int sc_fpscr;
47 unsigned int sc_fpul;
48 unsigned int sc_ownedfp;
49};
50
51struct target_sigframe
52{
53 struct target_sigcontext sc;
54 target_ulong extramask[TARGET_NSIG_WORDS-1];
55};
56
57
58struct target_ucontext {
59 target_ulong tuc_flags;
60 struct target_ucontext *tuc_link;
61 target_stack_t tuc_stack;
62 struct target_sigcontext tuc_mcontext;
63 target_sigset_t tuc_sigmask;
64};
65
66struct target_rt_sigframe
67{
68 struct target_siginfo info;
69 struct target_ucontext uc;
70};
71
72
73#define MOVW(n) (0x9300|((n)-2))
74#define TRAP_NOARG 0xc310
75
76static abi_ulong get_sigframe(struct target_sigaction *ka,
77 unsigned long sp, size_t frame_size)
78{
79 sp = target_sigsp(sp, ka);
80
81 return (sp - frame_size) & -8ul;
82}
83
84
85
86
87
88
89static void unwind_gusa(CPUSH4State *regs)
90{
91
92
93
94
95
96
97
98
99 if (regs->gregs[15] >= -128u && regs->pc < regs->gregs[0]) {
100
101
102
103 regs->pc = regs->gregs[0] + regs->gregs[15] - 2;
104
105
106 regs->gregs[15] = regs->gregs[1];
107 }
108}
109
110static void setup_sigcontext(struct target_sigcontext *sc,
111 CPUSH4State *regs, unsigned long mask)
112{
113 int i;
114
115#define COPY(x) __put_user(regs->x, &sc->sc_##x)
116 COPY(gregs[0]); COPY(gregs[1]);
117 COPY(gregs[2]); COPY(gregs[3]);
118 COPY(gregs[4]); COPY(gregs[5]);
119 COPY(gregs[6]); COPY(gregs[7]);
120 COPY(gregs[8]); COPY(gregs[9]);
121 COPY(gregs[10]); COPY(gregs[11]);
122 COPY(gregs[12]); COPY(gregs[13]);
123 COPY(gregs[14]); COPY(gregs[15]);
124 COPY(gbr); COPY(mach);
125 COPY(macl); COPY(pr);
126 COPY(sr); COPY(pc);
127#undef COPY
128
129 for (i=0; i<16; i++) {
130 __put_user(regs->fregs[i], &sc->sc_fpregs[i]);
131 }
132 __put_user(regs->fpscr, &sc->sc_fpscr);
133 __put_user(regs->fpul, &sc->sc_fpul);
134
135
136 __put_user(mask, &sc->oldmask);
137}
138
139static void restore_sigcontext(CPUSH4State *regs, struct target_sigcontext *sc)
140{
141 int i;
142
143#define COPY(x) __get_user(regs->x, &sc->sc_##x)
144 COPY(gregs[0]); COPY(gregs[1]);
145 COPY(gregs[2]); COPY(gregs[3]);
146 COPY(gregs[4]); COPY(gregs[5]);
147 COPY(gregs[6]); COPY(gregs[7]);
148 COPY(gregs[8]); COPY(gregs[9]);
149 COPY(gregs[10]); COPY(gregs[11]);
150 COPY(gregs[12]); COPY(gregs[13]);
151 COPY(gregs[14]); COPY(gregs[15]);
152 COPY(gbr); COPY(mach);
153 COPY(macl); COPY(pr);
154 COPY(sr); COPY(pc);
155#undef COPY
156
157 for (i=0; i<16; i++) {
158 __get_user(regs->fregs[i], &sc->sc_fpregs[i]);
159 }
160 __get_user(regs->fpscr, &sc->sc_fpscr);
161 __get_user(regs->fpul, &sc->sc_fpul);
162
163 regs->tra = -1;
164 regs->flags = 0;
165}
166
167void setup_frame(int sig, struct target_sigaction *ka,
168 target_sigset_t *set, CPUSH4State *regs)
169{
170 struct target_sigframe *frame;
171 abi_ulong frame_addr;
172 int i;
173
174 unwind_gusa(regs);
175
176 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
177 trace_user_setup_frame(regs, frame_addr);
178 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
179 goto give_sigsegv;
180 }
181
182 setup_sigcontext(&frame->sc, regs, set->sig[0]);
183
184 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
185 __put_user(set->sig[i + 1], &frame->extramask[i]);
186 }
187
188
189
190 if (ka->sa_flags & TARGET_SA_RESTORER) {
191 regs->pr = ka->sa_restorer;
192 } else {
193 regs->pr = default_sigreturn;
194 }
195
196
197 regs->gregs[15] = frame_addr;
198 regs->gregs[4] = sig;
199 regs->gregs[5] = 0;
200 regs->gregs[6] = frame_addr += offsetof(typeof(*frame), sc);
201 regs->pc = (unsigned long) ka->_sa_handler;
202 regs->flags &= ~(TB_FLAG_DELAY_SLOT_MASK | TB_FLAG_GUSA_MASK);
203
204 unlock_user_struct(frame, frame_addr, 1);
205 return;
206
207give_sigsegv:
208 unlock_user_struct(frame, frame_addr, 1);
209 force_sigsegv(sig);
210}
211
212void setup_rt_frame(int sig, struct target_sigaction *ka,
213 target_siginfo_t *info,
214 target_sigset_t *set, CPUSH4State *regs)
215{
216 struct target_rt_sigframe *frame;
217 abi_ulong frame_addr;
218 int i;
219
220 unwind_gusa(regs);
221
222 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
223 trace_user_setup_rt_frame(regs, frame_addr);
224 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
225 goto give_sigsegv;
226 }
227
228 tswap_siginfo(&frame->info, info);
229
230
231 __put_user(0, &frame->uc.tuc_flags);
232 __put_user(0, (unsigned long *)&frame->uc.tuc_link);
233 target_save_altstack(&frame->uc.tuc_stack, regs);
234 setup_sigcontext(&frame->uc.tuc_mcontext,
235 regs, set->sig[0]);
236 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
237 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
238 }
239
240
241
242 if (ka->sa_flags & TARGET_SA_RESTORER) {
243 regs->pr = ka->sa_restorer;
244 } else {
245 regs->pr = default_rt_sigreturn;
246 }
247
248
249 regs->gregs[15] = frame_addr;
250 regs->gregs[4] = sig;
251 regs->gregs[5] = frame_addr + offsetof(typeof(*frame), info);
252 regs->gregs[6] = frame_addr + offsetof(typeof(*frame), uc);
253 regs->pc = (unsigned long) ka->_sa_handler;
254 regs->flags &= ~(TB_FLAG_DELAY_SLOT_MASK | TB_FLAG_GUSA_MASK);
255
256 unlock_user_struct(frame, frame_addr, 1);
257 return;
258
259give_sigsegv:
260 unlock_user_struct(frame, frame_addr, 1);
261 force_sigsegv(sig);
262}
263
264long do_sigreturn(CPUSH4State *regs)
265{
266 struct target_sigframe *frame;
267 abi_ulong frame_addr;
268 sigset_t blocked;
269 target_sigset_t target_set;
270 int i;
271
272 frame_addr = regs->gregs[15];
273 trace_user_do_sigreturn(regs, frame_addr);
274 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
275 goto badframe;
276 }
277
278 __get_user(target_set.sig[0], &frame->sc.oldmask);
279 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
280 __get_user(target_set.sig[i], &frame->extramask[i - 1]);
281 }
282
283 target_to_host_sigset_internal(&blocked, &target_set);
284 set_sigmask(&blocked);
285
286 restore_sigcontext(regs, &frame->sc);
287
288 unlock_user_struct(frame, frame_addr, 0);
289 return -QEMU_ESIGRETURN;
290
291badframe:
292 unlock_user_struct(frame, frame_addr, 0);
293 force_sig(TARGET_SIGSEGV);
294 return -QEMU_ESIGRETURN;
295}
296
297long do_rt_sigreturn(CPUSH4State *regs)
298{
299 struct target_rt_sigframe *frame;
300 abi_ulong frame_addr;
301 sigset_t blocked;
302
303 frame_addr = regs->gregs[15];
304 trace_user_do_rt_sigreturn(regs, frame_addr);
305 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
306 goto badframe;
307 }
308
309 target_to_host_sigset(&blocked, &frame->uc.tuc_sigmask);
310 set_sigmask(&blocked);
311
312 restore_sigcontext(regs, &frame->uc.tuc_mcontext);
313 target_restore_altstack(&frame->uc.tuc_stack, regs);
314
315 unlock_user_struct(frame, frame_addr, 0);
316 return -QEMU_ESIGRETURN;
317
318badframe:
319 unlock_user_struct(frame, frame_addr, 0);
320 force_sig(TARGET_SIGSEGV);
321 return -QEMU_ESIGRETURN;
322}
323
324void setup_sigtramp(abi_ulong sigtramp_page)
325{
326 uint16_t *tramp = lock_user(VERIFY_WRITE, sigtramp_page, 2 * 6, 0);
327 assert(tramp != NULL);
328
329 default_sigreturn = sigtramp_page;
330 __put_user(MOVW(2), &tramp[0]);
331 __put_user(TRAP_NOARG, &tramp[1]);
332 __put_user(TARGET_NR_sigreturn, &tramp[2]);
333
334 default_rt_sigreturn = sigtramp_page + 6;
335 __put_user(MOVW(2), &tramp[3]);
336 __put_user(TRAP_NOARG, &tramp[4]);
337 __put_user(TARGET_NR_rt_sigreturn, &tramp[5]);
338
339 unlock_user(tramp, sigtramp_page, 2 * 6);
340}
341