1 /*
2 * Emulation of Linux signals
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
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 #include "target/arm/cpu-features.h"
25 #include "vdso-asmoffset.h"
26
27 struct target_sigcontext {
28 abi_ulong trap_no;
29 abi_ulong error_code;
30 abi_ulong oldmask;
31 abi_ulong arm_r0;
32 abi_ulong arm_r1;
33 abi_ulong arm_r2;
34 abi_ulong arm_r3;
35 abi_ulong arm_r4;
36 abi_ulong arm_r5;
37 abi_ulong arm_r6;
38 abi_ulong arm_r7;
39 abi_ulong arm_r8;
40 abi_ulong arm_r9;
41 abi_ulong arm_r10;
42 abi_ulong arm_fp;
43 abi_ulong arm_ip;
44 abi_ulong arm_sp;
45 abi_ulong arm_lr;
46 abi_ulong arm_pc;
47 abi_ulong arm_cpsr;
48 abi_ulong fault_address;
49 };
50
51 struct target_ucontext {
52 abi_ulong tuc_flags;
53 abi_ulong tuc_link;
54 target_stack_t tuc_stack;
55 struct target_sigcontext tuc_mcontext;
56 target_sigset_t tuc_sigmask; /* mask last for extensibility */
57 char __unused[128 - sizeof(target_sigset_t)];
58 abi_ulong tuc_regspace[128] __attribute__((__aligned__(8)));
59 };
60
61 struct target_user_vfp {
62 uint64_t fpregs[32];
63 abi_ulong fpscr;
64 };
65
66 struct target_user_vfp_exc {
67 abi_ulong fpexc;
68 abi_ulong fpinst;
69 abi_ulong fpinst2;
70 };
71
72 struct target_vfp_sigframe {
73 abi_ulong magic;
74 abi_ulong size;
75 struct target_user_vfp ufp;
76 struct target_user_vfp_exc ufp_exc;
77 } __attribute__((__aligned__(8)));
78
79 struct target_iwmmxt_sigframe {
80 abi_ulong magic;
81 abi_ulong size;
82 uint64_t regs[16];
83 /* Note that not all the coprocessor control registers are stored here */
84 uint32_t wcssf;
85 uint32_t wcasf;
86 uint32_t wcgr0;
87 uint32_t wcgr1;
88 uint32_t wcgr2;
89 uint32_t wcgr3;
90 } __attribute__((__aligned__(8)));
91
92 #define TARGET_VFP_MAGIC 0x56465001
93 #define TARGET_IWMMXT_MAGIC 0x12ef842a
94
95 struct sigframe
96 {
97 struct target_ucontext uc;
98 abi_ulong retcode[4];
99 };
100
101 struct rt_sigframe
102 {
103 struct target_siginfo info;
104 struct sigframe sig;
105 };
106
107 QEMU_BUILD_BUG_ON(offsetof(struct sigframe, retcode[3])
108 != SIGFRAME_RC3_OFFSET);
109 QEMU_BUILD_BUG_ON(offsetof(struct rt_sigframe, sig.retcode[3])
110 != RT_SIGFRAME_RC3_OFFSET);
111
112 static abi_ptr sigreturn_fdpic_tramp;
113
114 /*
115 * Up to 3 words of 'retcode' in the sigframe are code,
116 * with retcode[3] being used by fdpic for the function descriptor.
117 * This code is not actually executed, but is retained for ABI compat.
118 *
119 * We will create a table of 8 retcode variants in the sigtramp page.
120 * Let each table entry use 3 words.
121 */
122 #define RETCODE_WORDS 3
123 #define RETCODE_BYTES (RETCODE_WORDS * 4)
124
valid_user_regs(CPUARMState * regs)125 static inline int valid_user_regs(CPUARMState *regs)
126 {
127 return 1;
128 }
129
130 static void
setup_sigcontext(struct target_sigcontext * sc,CPUARMState * env,abi_ulong mask)131 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
132 CPUARMState *env, abi_ulong mask)
133 {
134 __put_user(env->regs[0], &sc->arm_r0);
135 __put_user(env->regs[1], &sc->arm_r1);
136 __put_user(env->regs[2], &sc->arm_r2);
137 __put_user(env->regs[3], &sc->arm_r3);
138 __put_user(env->regs[4], &sc->arm_r4);
139 __put_user(env->regs[5], &sc->arm_r5);
140 __put_user(env->regs[6], &sc->arm_r6);
141 __put_user(env->regs[7], &sc->arm_r7);
142 __put_user(env->regs[8], &sc->arm_r8);
143 __put_user(env->regs[9], &sc->arm_r9);
144 __put_user(env->regs[10], &sc->arm_r10);
145 __put_user(env->regs[11], &sc->arm_fp);
146 __put_user(env->regs[12], &sc->arm_ip);
147 __put_user(env->regs[13], &sc->arm_sp);
148 __put_user(env->regs[14], &sc->arm_lr);
149 __put_user(env->regs[15], &sc->arm_pc);
150 __put_user(cpsr_read(env), &sc->arm_cpsr);
151
152 __put_user(/* current->thread.trap_no */ 0, &sc->trap_no);
153 __put_user(/* current->thread.error_code */ 0, &sc->error_code);
154 __put_user(/* current->thread.address */ 0, &sc->fault_address);
155 __put_user(mask, &sc->oldmask);
156 }
157
158 static inline abi_ulong
get_sigframe(struct target_sigaction * ka,CPUARMState * regs,int framesize)159 get_sigframe(struct target_sigaction *ka, CPUARMState *regs, int framesize)
160 {
161 unsigned long sp;
162
163 sp = target_sigsp(get_sp_from_cpustate(regs), ka);
164 /*
165 * ATPCS B01 mandates 8-byte alignment
166 */
167 return (sp - framesize) & ~7;
168 }
169
170 static void write_arm_sigreturn(uint32_t *rc, int syscall);
171 static void write_arm_fdpic_sigreturn(uint32_t *rc, int ofs);
172
173 static int
setup_return(CPUARMState * env,struct target_sigaction * ka,int usig,struct sigframe * frame,abi_ulong sp_addr)174 setup_return(CPUARMState *env, struct target_sigaction *ka, int usig,
175 struct sigframe *frame, abi_ulong sp_addr)
176 {
177 abi_ulong handler = 0;
178 abi_ulong handler_fdpic_GOT = 0;
179 abi_ulong retcode;
180 bool is_fdpic = info_is_fdpic(get_task_state(thread_cpu)->info);
181 bool is_rt = ka->sa_flags & TARGET_SA_SIGINFO;
182 bool thumb;
183
184 if (is_fdpic) {
185 /* In FDPIC mode, ka->_sa_handler points to a function
186 * descriptor (FD). The first word contains the address of the
187 * handler. The second word contains the value of the PIC
188 * register (r9). */
189 abi_ulong funcdesc_ptr = ka->_sa_handler;
190 if (get_user_ual(handler, funcdesc_ptr)
191 || get_user_ual(handler_fdpic_GOT, funcdesc_ptr + 4)) {
192 return 1;
193 }
194 } else {
195 handler = ka->_sa_handler;
196 }
197 thumb = handler & 1;
198
199 uint32_t cpsr = cpsr_read(env);
200
201 cpsr &= ~CPSR_IT;
202 if (thumb) {
203 cpsr |= CPSR_T;
204 } else {
205 cpsr &= ~CPSR_T;
206 }
207 if (env->cp15.sctlr_el[1] & SCTLR_E0E) {
208 cpsr |= CPSR_E;
209 } else {
210 cpsr &= ~CPSR_E;
211 }
212
213 /* Our vdso default_sigreturn label is a table of entry points. */
214 retcode = default_sigreturn + (is_fdpic * 2 + is_rt) * 8;
215
216 /*
217 * Put the sigreturn code on the stack no matter which return
218 * mechanism we use in order to remain ABI compliant.
219 * Because this is about ABI, always use the A32 instructions,
220 * despite the fact that our actual vdso trampoline is T16.
221 */
222 if (is_fdpic) {
223 write_arm_fdpic_sigreturn(frame->retcode,
224 is_rt ? RT_SIGFRAME_RC3_OFFSET
225 : SIGFRAME_RC3_OFFSET);
226 } else {
227 write_arm_sigreturn(frame->retcode,
228 is_rt ? TARGET_NR_rt_sigreturn
229 : TARGET_NR_sigreturn);
230 }
231
232 if (ka->sa_flags & TARGET_SA_RESTORER) {
233 if (is_fdpic) {
234 /* Place the function descriptor in slot 3. */
235 __put_user((abi_ulong)ka->sa_restorer, &frame->retcode[3]);
236 } else {
237 retcode = ka->sa_restorer;
238 }
239 }
240
241 env->regs[0] = usig;
242 if (is_fdpic) {
243 env->regs[9] = handler_fdpic_GOT;
244 }
245 env->regs[13] = sp_addr;
246 env->regs[14] = retcode;
247 env->regs[15] = handler & (thumb ? ~1 : ~3);
248 cpsr_write(env, cpsr, CPSR_IT | CPSR_T | CPSR_E, CPSRWriteByInstr);
249
250 return 0;
251 }
252
setup_sigframe_vfp(abi_ulong * regspace,CPUARMState * env)253 static abi_ulong *setup_sigframe_vfp(abi_ulong *regspace, CPUARMState *env)
254 {
255 int i;
256 struct target_vfp_sigframe *vfpframe;
257 vfpframe = (struct target_vfp_sigframe *)regspace;
258 __put_user(TARGET_VFP_MAGIC, &vfpframe->magic);
259 __put_user(sizeof(*vfpframe), &vfpframe->size);
260 for (i = 0; i < 32; i++) {
261 __put_user(*aa32_vfp_dreg(env, i), &vfpframe->ufp.fpregs[i]);
262 }
263 __put_user(vfp_get_fpscr(env), &vfpframe->ufp.fpscr);
264 __put_user(env->vfp.xregs[ARM_VFP_FPEXC], &vfpframe->ufp_exc.fpexc);
265 __put_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst);
266 __put_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2);
267 return (abi_ulong*)(vfpframe+1);
268 }
269
setup_sigframe_iwmmxt(abi_ulong * regspace,CPUARMState * env)270 static abi_ulong *setup_sigframe_iwmmxt(abi_ulong *regspace, CPUARMState *env)
271 {
272 int i;
273 struct target_iwmmxt_sigframe *iwmmxtframe;
274 iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace;
275 __put_user(TARGET_IWMMXT_MAGIC, &iwmmxtframe->magic);
276 __put_user(sizeof(*iwmmxtframe), &iwmmxtframe->size);
277 for (i = 0; i < 16; i++) {
278 __put_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]);
279 }
280 __put_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf);
281 __put_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf);
282 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0);
283 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1);
284 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2);
285 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3);
286 return (abi_ulong*)(iwmmxtframe+1);
287 }
288
setup_sigframe(struct target_ucontext * uc,target_sigset_t * set,CPUARMState * env)289 static void setup_sigframe(struct target_ucontext *uc,
290 target_sigset_t *set, CPUARMState *env)
291 {
292 struct target_sigaltstack stack;
293 int i;
294 abi_ulong *regspace;
295
296 /* Clear all the bits of the ucontext we don't use. */
297 memset(uc, 0, offsetof(struct target_ucontext, tuc_mcontext));
298
299 memset(&stack, 0, sizeof(stack));
300 target_save_altstack(&stack, env);
301 memcpy(&uc->tuc_stack, &stack, sizeof(stack));
302
303 setup_sigcontext(&uc->tuc_mcontext, env, set->sig[0]);
304 /* Save coprocessor signal frame. */
305 regspace = uc->tuc_regspace;
306 if (cpu_isar_feature(aa32_vfp_simd, env_archcpu(env))) {
307 regspace = setup_sigframe_vfp(regspace, env);
308 }
309 if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
310 regspace = setup_sigframe_iwmmxt(regspace, env);
311 }
312
313 /* Write terminating magic word */
314 __put_user(0, regspace);
315
316 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
317 __put_user(set->sig[i], &uc->tuc_sigmask.sig[i]);
318 }
319 }
320
setup_frame(int usig,struct target_sigaction * ka,target_sigset_t * set,CPUARMState * regs)321 void setup_frame(int usig, struct target_sigaction *ka,
322 target_sigset_t *set, CPUARMState *regs)
323 {
324 struct sigframe *frame;
325 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
326
327 trace_user_setup_frame(regs, frame_addr);
328 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
329 goto sigsegv;
330 }
331
332 setup_sigframe(&frame->uc, set, regs);
333
334 if (setup_return(regs, ka, usig, frame, frame_addr)) {
335 goto sigsegv;
336 }
337
338 unlock_user_struct(frame, frame_addr, 1);
339 return;
340 sigsegv:
341 unlock_user_struct(frame, frame_addr, 1);
342 force_sigsegv(usig);
343 }
344
setup_rt_frame(int usig,struct target_sigaction * ka,target_siginfo_t * info,target_sigset_t * set,CPUARMState * env)345 void setup_rt_frame(int usig, struct target_sigaction *ka,
346 target_siginfo_t *info,
347 target_sigset_t *set, CPUARMState *env)
348 {
349 struct rt_sigframe *frame;
350 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
351 abi_ulong info_addr, uc_addr;
352
353 trace_user_setup_rt_frame(env, frame_addr);
354 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
355 goto sigsegv;
356 }
357
358 info_addr = frame_addr + offsetof(struct rt_sigframe, info);
359 uc_addr = frame_addr + offsetof(struct rt_sigframe, sig.uc);
360 frame->info = *info;
361
362 setup_sigframe(&frame->sig.uc, set, env);
363
364 if (setup_return(env, ka, usig, &frame->sig, frame_addr)) {
365 goto sigsegv;
366 }
367
368 env->regs[1] = info_addr;
369 env->regs[2] = uc_addr;
370
371 unlock_user_struct(frame, frame_addr, 1);
372 return;
373 sigsegv:
374 unlock_user_struct(frame, frame_addr, 1);
375 force_sigsegv(usig);
376 }
377
378 static int
restore_sigcontext(CPUARMState * env,struct target_sigcontext * sc)379 restore_sigcontext(CPUARMState *env, struct target_sigcontext *sc)
380 {
381 int err = 0;
382 uint32_t cpsr;
383
384 __get_user(env->regs[0], &sc->arm_r0);
385 __get_user(env->regs[1], &sc->arm_r1);
386 __get_user(env->regs[2], &sc->arm_r2);
387 __get_user(env->regs[3], &sc->arm_r3);
388 __get_user(env->regs[4], &sc->arm_r4);
389 __get_user(env->regs[5], &sc->arm_r5);
390 __get_user(env->regs[6], &sc->arm_r6);
391 __get_user(env->regs[7], &sc->arm_r7);
392 __get_user(env->regs[8], &sc->arm_r8);
393 __get_user(env->regs[9], &sc->arm_r9);
394 __get_user(env->regs[10], &sc->arm_r10);
395 __get_user(env->regs[11], &sc->arm_fp);
396 __get_user(env->regs[12], &sc->arm_ip);
397 __get_user(env->regs[13], &sc->arm_sp);
398 __get_user(env->regs[14], &sc->arm_lr);
399 __get_user(env->regs[15], &sc->arm_pc);
400 __get_user(cpsr, &sc->arm_cpsr);
401 cpsr_write(env, cpsr, CPSR_USER | CPSR_EXEC, CPSRWriteByInstr);
402
403 err |= !valid_user_regs(env);
404
405 return err;
406 }
407
restore_sigframe_vfp(CPUARMState * env,abi_ulong * regspace)408 static abi_ulong *restore_sigframe_vfp(CPUARMState *env, abi_ulong *regspace)
409 {
410 int i;
411 abi_ulong magic, sz;
412 uint32_t fpscr, fpexc;
413 struct target_vfp_sigframe *vfpframe;
414 vfpframe = (struct target_vfp_sigframe *)regspace;
415
416 __get_user(magic, &vfpframe->magic);
417 __get_user(sz, &vfpframe->size);
418 if (magic != TARGET_VFP_MAGIC || sz != sizeof(*vfpframe)) {
419 return 0;
420 }
421 for (i = 0; i < 32; i++) {
422 __get_user(*aa32_vfp_dreg(env, i), &vfpframe->ufp.fpregs[i]);
423 }
424 __get_user(fpscr, &vfpframe->ufp.fpscr);
425 vfp_set_fpscr(env, fpscr);
426 __get_user(fpexc, &vfpframe->ufp_exc.fpexc);
427 /* Sanitise FPEXC: ensure VFP is enabled, FPINST2 is invalid
428 * and the exception flag is cleared
429 */
430 fpexc |= (1 << 30);
431 fpexc &= ~((1 << 31) | (1 << 28));
432 env->vfp.xregs[ARM_VFP_FPEXC] = fpexc;
433 __get_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst);
434 __get_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2);
435 return (abi_ulong*)(vfpframe + 1);
436 }
437
restore_sigframe_iwmmxt(CPUARMState * env,abi_ulong * regspace)438 static abi_ulong *restore_sigframe_iwmmxt(CPUARMState *env,
439 abi_ulong *regspace)
440 {
441 int i;
442 abi_ulong magic, sz;
443 struct target_iwmmxt_sigframe *iwmmxtframe;
444 iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace;
445
446 __get_user(magic, &iwmmxtframe->magic);
447 __get_user(sz, &iwmmxtframe->size);
448 if (magic != TARGET_IWMMXT_MAGIC || sz != sizeof(*iwmmxtframe)) {
449 return 0;
450 }
451 for (i = 0; i < 16; i++) {
452 __get_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]);
453 }
454 __get_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf);
455 __get_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf);
456 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0);
457 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1);
458 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2);
459 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3);
460 return (abi_ulong*)(iwmmxtframe + 1);
461 }
462
do_sigframe_return(CPUARMState * env,target_ulong context_addr,struct target_ucontext * uc)463 static int do_sigframe_return(CPUARMState *env,
464 target_ulong context_addr,
465 struct target_ucontext *uc)
466 {
467 sigset_t host_set;
468 abi_ulong *regspace;
469
470 target_to_host_sigset(&host_set, &uc->tuc_sigmask);
471 set_sigmask(&host_set);
472
473 if (restore_sigcontext(env, &uc->tuc_mcontext)) {
474 return 1;
475 }
476
477 /* Restore coprocessor signal frame */
478 regspace = uc->tuc_regspace;
479 if (cpu_isar_feature(aa32_vfp_simd, env_archcpu(env))) {
480 regspace = restore_sigframe_vfp(env, regspace);
481 if (!regspace) {
482 return 1;
483 }
484 }
485 if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
486 regspace = restore_sigframe_iwmmxt(env, regspace);
487 if (!regspace) {
488 return 1;
489 }
490 }
491
492 target_restore_altstack(&uc->tuc_stack, env);
493
494 #if 0
495 /* Send SIGTRAP if we're single-stepping */
496 if (ptrace_cancel_bpt(current))
497 send_sig(SIGTRAP, current, 1);
498 #endif
499
500 return 0;
501 }
502
do_sigreturn(CPUARMState * env)503 long do_sigreturn(CPUARMState *env)
504 {
505 abi_ulong frame_addr;
506 struct sigframe *frame = NULL;
507
508 /*
509 * Since we stacked the signal on a 64-bit boundary,
510 * then 'sp' should be word aligned here. If it's
511 * not, then the user is trying to mess with us.
512 */
513 frame_addr = env->regs[13];
514 trace_user_do_sigreturn(env, frame_addr);
515 if (frame_addr & 7) {
516 goto badframe;
517 }
518
519 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
520 goto badframe;
521 }
522
523 if (do_sigframe_return(env,
524 frame_addr + offsetof(struct sigframe, uc),
525 &frame->uc)) {
526 goto badframe;
527 }
528
529 unlock_user_struct(frame, frame_addr, 0);
530 return -QEMU_ESIGRETURN;
531
532 badframe:
533 unlock_user_struct(frame, frame_addr, 0);
534 force_sig(TARGET_SIGSEGV);
535 return -QEMU_ESIGRETURN;
536 }
537
do_rt_sigreturn(CPUARMState * env)538 long do_rt_sigreturn(CPUARMState *env)
539 {
540 abi_ulong frame_addr;
541 struct rt_sigframe *frame = NULL;
542
543 /*
544 * Since we stacked the signal on a 64-bit boundary,
545 * then 'sp' should be word aligned here. If it's
546 * not, then the user is trying to mess with us.
547 */
548 frame_addr = env->regs[13];
549 trace_user_do_rt_sigreturn(env, frame_addr);
550 if (frame_addr & 7) {
551 goto badframe;
552 }
553
554 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
555 goto badframe;
556 }
557
558 if (do_sigframe_return(env,
559 frame_addr + offsetof(struct rt_sigframe, sig.uc),
560 &frame->sig.uc)) {
561 goto badframe;
562 }
563
564 unlock_user_struct(frame, frame_addr, 0);
565 return -QEMU_ESIGRETURN;
566
567 badframe:
568 unlock_user_struct(frame, frame_addr, 0);
569 force_sig(TARGET_SIGSEGV);
570 return -QEMU_ESIGRETURN;
571 }
572
573 /*
574 * EABI syscalls pass the number via r7.
575 * Note that the kernel still adds the OABI syscall number to the trap,
576 * presumably for backward ABI compatibility with unwinders.
577 */
578 #define ARM_MOV_R7_IMM(X) (0xe3a07000 | (X))
579 #define ARM_SWI_SYS(X) (0xef000000 | (X) | ARM_SYSCALL_BASE)
580
581 #define THUMB_MOVS_R7_IMM(X) (0x2700 | (X))
582 #define THUMB_SWI_SYS 0xdf00
583
write_arm_sigreturn(uint32_t * rc,int syscall)584 static void write_arm_sigreturn(uint32_t *rc, int syscall)
585 {
586 __put_user(ARM_MOV_R7_IMM(syscall), rc);
587 __put_user(ARM_SWI_SYS(syscall), rc + 1);
588 /* Wrote 8 of 12 bytes */
589 }
590
write_thm_sigreturn(uint32_t * rc,int syscall)591 static void write_thm_sigreturn(uint32_t *rc, int syscall)
592 {
593 __put_user(THUMB_SWI_SYS << 16 | THUMB_MOVS_R7_IMM(syscall), rc);
594 /* Wrote 4 of 12 bytes */
595 }
596
597 /*
598 * Stub needed to make sure the FD register (r9) contains the right value.
599 * Use the same instruction sequence as the kernel.
600 */
write_arm_fdpic_sigreturn(uint32_t * rc,int ofs)601 static void write_arm_fdpic_sigreturn(uint32_t *rc, int ofs)
602 {
603 assert(ofs <= 0xfff);
604 __put_user(0xe59d3000 | ofs, rc + 0); /* ldr r3, [sp, #ofs] */
605 __put_user(0xe8930908, rc + 1); /* ldm r3, { r3, r9 } */
606 __put_user(0xe12fff13, rc + 2); /* bx r3 */
607 /* Wrote 12 of 12 bytes */
608 }
609
write_thm_fdpic_sigreturn(void * vrc,int ofs)610 static void write_thm_fdpic_sigreturn(void *vrc, int ofs)
611 {
612 uint16_t *rc = vrc;
613
614 assert((ofs & ~0x3fc) == 0);
615 __put_user(0x9b00 | (ofs >> 2), rc + 0); /* ldr r3, [sp, #ofs] */
616 __put_user(0xcb0c, rc + 1); /* ldm r3, { r2, r3 } */
617 __put_user(0x4699, rc + 2); /* mov r9, r3 */
618 __put_user(0x4710, rc + 3); /* bx r2 */
619 /* Wrote 8 of 12 bytes */
620 }
621
setup_sigtramp(abi_ulong sigtramp_page)622 void setup_sigtramp(abi_ulong sigtramp_page)
623 {
624 uint32_t total_size = 8 * RETCODE_BYTES;
625 uint32_t *tramp = lock_user(VERIFY_WRITE, sigtramp_page, total_size, 0);
626
627 assert(tramp != NULL);
628
629 default_sigreturn = sigtramp_page;
630 write_arm_sigreturn(&tramp[0 * RETCODE_WORDS], TARGET_NR_sigreturn);
631 write_thm_sigreturn(&tramp[1 * RETCODE_WORDS], TARGET_NR_sigreturn);
632 write_arm_sigreturn(&tramp[2 * RETCODE_WORDS], TARGET_NR_rt_sigreturn);
633 write_thm_sigreturn(&tramp[3 * RETCODE_WORDS], TARGET_NR_rt_sigreturn);
634
635 sigreturn_fdpic_tramp = sigtramp_page + 4 * RETCODE_BYTES;
636 write_arm_fdpic_sigreturn(tramp + 4 * RETCODE_WORDS,
637 offsetof(struct sigframe, retcode[3]));
638 write_thm_fdpic_sigreturn(tramp + 5 * RETCODE_WORDS,
639 offsetof(struct sigframe, retcode[3]));
640 write_arm_fdpic_sigreturn(tramp + 6 * RETCODE_WORDS,
641 offsetof(struct rt_sigframe, sig.retcode[3]));
642 write_thm_fdpic_sigreturn(tramp + 7 * RETCODE_WORDS,
643 offsetof(struct rt_sigframe, sig.retcode[3]));
644
645 unlock_user(tramp, sigtramp_page, total_size);
646 }
647