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