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 "signal-common.h"
22 #include "linux-user/trace.h"
23 
24 struct target_sigcontext {
25     abi_ulong trap_no;
26     abi_ulong error_code;
27     abi_ulong oldmask;
28     abi_ulong arm_r0;
29     abi_ulong arm_r1;
30     abi_ulong arm_r2;
31     abi_ulong arm_r3;
32     abi_ulong arm_r4;
33     abi_ulong arm_r5;
34     abi_ulong arm_r6;
35     abi_ulong arm_r7;
36     abi_ulong arm_r8;
37     abi_ulong arm_r9;
38     abi_ulong arm_r10;
39     abi_ulong arm_fp;
40     abi_ulong arm_ip;
41     abi_ulong arm_sp;
42     abi_ulong arm_lr;
43     abi_ulong arm_pc;
44     abi_ulong arm_cpsr;
45     abi_ulong fault_address;
46 };
47 
48 struct target_ucontext_v1 {
49     abi_ulong tuc_flags;
50     abi_ulong tuc_link;
51     target_stack_t tuc_stack;
52     struct target_sigcontext tuc_mcontext;
53     target_sigset_t  tuc_sigmask;       /* mask last for extensibility */
54 };
55 
56 struct target_ucontext_v2 {
57     abi_ulong tuc_flags;
58     abi_ulong tuc_link;
59     target_stack_t tuc_stack;
60     struct target_sigcontext tuc_mcontext;
61     target_sigset_t  tuc_sigmask;       /* mask last for extensibility */
62     char __unused[128 - sizeof(target_sigset_t)];
63     abi_ulong tuc_regspace[128] __attribute__((__aligned__(8)));
64 };
65 
66 struct target_user_vfp {
67     uint64_t fpregs[32];
68     abi_ulong fpscr;
69 };
70 
71 struct target_user_vfp_exc {
72     abi_ulong fpexc;
73     abi_ulong fpinst;
74     abi_ulong fpinst2;
75 };
76 
77 struct target_vfp_sigframe {
78     abi_ulong magic;
79     abi_ulong size;
80     struct target_user_vfp ufp;
81     struct target_user_vfp_exc ufp_exc;
82 } __attribute__((__aligned__(8)));
83 
84 struct target_iwmmxt_sigframe {
85     abi_ulong magic;
86     abi_ulong size;
87     uint64_t regs[16];
88     /* Note that not all the coprocessor control registers are stored here */
89     uint32_t wcssf;
90     uint32_t wcasf;
91     uint32_t wcgr0;
92     uint32_t wcgr1;
93     uint32_t wcgr2;
94     uint32_t wcgr3;
95 } __attribute__((__aligned__(8)));
96 
97 #define TARGET_VFP_MAGIC 0x56465001
98 #define TARGET_IWMMXT_MAGIC 0x12ef842a
99 
100 struct sigframe_v1
101 {
102     struct target_sigcontext sc;
103     abi_ulong extramask[TARGET_NSIG_WORDS-1];
104     abi_ulong retcode[4];
105 };
106 
107 struct sigframe_v2
108 {
109     struct target_ucontext_v2 uc;
110     abi_ulong retcode[4];
111 };
112 
113 struct rt_sigframe_v1
114 {
115     abi_ulong pinfo;
116     abi_ulong puc;
117     struct target_siginfo info;
118     struct target_ucontext_v1 uc;
119     abi_ulong retcode[4];
120 };
121 
122 struct rt_sigframe_v2
123 {
124     struct target_siginfo info;
125     struct target_ucontext_v2 uc;
126     abi_ulong retcode[4];
127 };
128 
129 #define TARGET_CONFIG_CPU_32 1
130 
131 /*
132  * For ARM syscalls, we encode the syscall number into the instruction.
133  */
134 #define SWI_SYS_SIGRETURN       (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
135 #define SWI_SYS_RT_SIGRETURN    (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
136 
137 /*
138  * For Thumb syscalls, we pass the syscall number via r7.  We therefore
139  * need two 16-bit instructions.
140  */
141 #define SWI_THUMB_SIGRETURN     (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
142 #define SWI_THUMB_RT_SIGRETURN  (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
143 
144 static const abi_ulong retcodes[4] = {
145         SWI_SYS_SIGRETURN,      SWI_THUMB_SIGRETURN,
146         SWI_SYS_RT_SIGRETURN,   SWI_THUMB_RT_SIGRETURN
147 };
148 
149 /*
150  * Stub needed to make sure the FD register (r9) contains the right
151  * value.
152  */
153 static const unsigned long sigreturn_fdpic_codes[3] = {
154     0xe59fc004, /* ldr r12, [pc, #4] to read function descriptor */
155     0xe59c9004, /* ldr r9, [r12, #4] to setup GOT */
156     0xe59cf000  /* ldr pc, [r12] to jump into restorer */
157 };
158 
159 static const unsigned long sigreturn_fdpic_thumb_codes[3] = {
160     0xc008f8df, /* ldr r12, [pc, #8] to read function descriptor */
161     0x9004f8dc, /* ldr r9, [r12, #4] to setup GOT */
162     0xf000f8dc  /* ldr pc, [r12] to jump into restorer */
163 };
164 
valid_user_regs(CPUARMState * regs)165 static inline int valid_user_regs(CPUARMState *regs)
166 {
167     return 1;
168 }
169 
170 static void
setup_sigcontext(struct target_sigcontext * sc,CPUARMState * env,abi_ulong mask)171 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
172                  CPUARMState *env, abi_ulong mask)
173 {
174     __put_user(env->regs[0], &sc->arm_r0);
175     __put_user(env->regs[1], &sc->arm_r1);
176     __put_user(env->regs[2], &sc->arm_r2);
177     __put_user(env->regs[3], &sc->arm_r3);
178     __put_user(env->regs[4], &sc->arm_r4);
179     __put_user(env->regs[5], &sc->arm_r5);
180     __put_user(env->regs[6], &sc->arm_r6);
181     __put_user(env->regs[7], &sc->arm_r7);
182     __put_user(env->regs[8], &sc->arm_r8);
183     __put_user(env->regs[9], &sc->arm_r9);
184     __put_user(env->regs[10], &sc->arm_r10);
185     __put_user(env->regs[11], &sc->arm_fp);
186     __put_user(env->regs[12], &sc->arm_ip);
187     __put_user(env->regs[13], &sc->arm_sp);
188     __put_user(env->regs[14], &sc->arm_lr);
189     __put_user(env->regs[15], &sc->arm_pc);
190 #ifdef TARGET_CONFIG_CPU_32
191     __put_user(cpsr_read(env), &sc->arm_cpsr);
192 #endif
193 
194     __put_user(/* current->thread.trap_no */ 0, &sc->trap_no);
195     __put_user(/* current->thread.error_code */ 0, &sc->error_code);
196     __put_user(/* current->thread.address */ 0, &sc->fault_address);
197     __put_user(mask, &sc->oldmask);
198 }
199 
200 static inline abi_ulong
get_sigframe(struct target_sigaction * ka,CPUARMState * regs,int framesize)201 get_sigframe(struct target_sigaction *ka, CPUARMState *regs, int framesize)
202 {
203     unsigned long sp;
204 
205     sp = target_sigsp(get_sp_from_cpustate(regs), ka);
206     /*
207      * ATPCS B01 mandates 8-byte alignment
208      */
209     return (sp - framesize) & ~7;
210 }
211 
212 static int
setup_return(CPUARMState * env,struct target_sigaction * ka,abi_ulong * rc,abi_ulong frame_addr,int usig,abi_ulong rc_addr)213 setup_return(CPUARMState *env, struct target_sigaction *ka,
214              abi_ulong *rc, abi_ulong frame_addr, int usig, abi_ulong rc_addr)
215 {
216     abi_ulong handler = 0;
217     abi_ulong handler_fdpic_GOT = 0;
218     abi_ulong retcode;
219 
220     int thumb;
221     int is_fdpic = info_is_fdpic(((TaskState *)thread_cpu->opaque)->info);
222 
223     if (is_fdpic) {
224         /* In FDPIC mode, ka->_sa_handler points to a function
225          * descriptor (FD). The first word contains the address of the
226          * handler. The second word contains the value of the PIC
227          * register (r9).  */
228         abi_ulong funcdesc_ptr = ka->_sa_handler;
229         if (get_user_ual(handler, funcdesc_ptr)
230             || get_user_ual(handler_fdpic_GOT, funcdesc_ptr + 4)) {
231             return 1;
232         }
233     } else {
234         handler = ka->_sa_handler;
235     }
236 
237     thumb = handler & 1;
238 
239     uint32_t cpsr = cpsr_read(env);
240 
241     cpsr &= ~CPSR_IT;
242     if (thumb) {
243         cpsr |= CPSR_T;
244     } else {
245         cpsr &= ~CPSR_T;
246     }
247 
248     if (ka->sa_flags & TARGET_SA_RESTORER) {
249         if (is_fdpic) {
250             /* For FDPIC we ensure that the restorer is called with a
251              * correct r9 value.  For that we need to write code on
252              * the stack that sets r9 and jumps back to restorer
253              * value.
254              */
255             if (thumb) {
256                 __put_user(sigreturn_fdpic_thumb_codes[0], rc);
257                 __put_user(sigreturn_fdpic_thumb_codes[1], rc + 1);
258                 __put_user(sigreturn_fdpic_thumb_codes[2], rc + 2);
259                 __put_user((abi_ulong)ka->sa_restorer, rc + 3);
260             } else {
261                 __put_user(sigreturn_fdpic_codes[0], rc);
262                 __put_user(sigreturn_fdpic_codes[1], rc + 1);
263                 __put_user(sigreturn_fdpic_codes[2], rc + 2);
264                 __put_user((abi_ulong)ka->sa_restorer, rc + 3);
265             }
266 
267             retcode = rc_addr + thumb;
268         } else {
269             retcode = ka->sa_restorer;
270         }
271     } else {
272         unsigned int idx = thumb;
273 
274         if (ka->sa_flags & TARGET_SA_SIGINFO) {
275             idx += 2;
276         }
277 
278         __put_user(retcodes[idx], rc);
279 
280         retcode = rc_addr + thumb;
281     }
282 
283     env->regs[0] = usig;
284     if (is_fdpic) {
285         env->regs[9] = handler_fdpic_GOT;
286     }
287     env->regs[13] = frame_addr;
288     env->regs[14] = retcode;
289     env->regs[15] = handler & (thumb ? ~1 : ~3);
290     cpsr_write(env, cpsr, CPSR_IT | CPSR_T, CPSRWriteByInstr);
291 
292     return 0;
293 }
294 
setup_sigframe_v2_vfp(abi_ulong * regspace,CPUARMState * env)295 static abi_ulong *setup_sigframe_v2_vfp(abi_ulong *regspace, CPUARMState *env)
296 {
297     int i;
298     struct target_vfp_sigframe *vfpframe;
299     vfpframe = (struct target_vfp_sigframe *)regspace;
300     __put_user(TARGET_VFP_MAGIC, &vfpframe->magic);
301     __put_user(sizeof(*vfpframe), &vfpframe->size);
302     for (i = 0; i < 32; i++) {
303         __put_user(*aa32_vfp_dreg(env, i), &vfpframe->ufp.fpregs[i]);
304     }
305     __put_user(vfp_get_fpscr(env), &vfpframe->ufp.fpscr);
306     __put_user(env->vfp.xregs[ARM_VFP_FPEXC], &vfpframe->ufp_exc.fpexc);
307     __put_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst);
308     __put_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2);
309     return (abi_ulong*)(vfpframe+1);
310 }
311 
setup_sigframe_v2_iwmmxt(abi_ulong * regspace,CPUARMState * env)312 static abi_ulong *setup_sigframe_v2_iwmmxt(abi_ulong *regspace,
313                                            CPUARMState *env)
314 {
315     int i;
316     struct target_iwmmxt_sigframe *iwmmxtframe;
317     iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace;
318     __put_user(TARGET_IWMMXT_MAGIC, &iwmmxtframe->magic);
319     __put_user(sizeof(*iwmmxtframe), &iwmmxtframe->size);
320     for (i = 0; i < 16; i++) {
321         __put_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]);
322     }
323     __put_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf);
324     __put_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf);
325     __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0);
326     __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1);
327     __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2);
328     __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3);
329     return (abi_ulong*)(iwmmxtframe+1);
330 }
331 
setup_sigframe_v2(struct target_ucontext_v2 * uc,target_sigset_t * set,CPUARMState * env)332 static void setup_sigframe_v2(struct target_ucontext_v2 *uc,
333                               target_sigset_t *set, CPUARMState *env)
334 {
335     struct target_sigaltstack stack;
336     int i;
337     abi_ulong *regspace;
338 
339     /* Clear all the bits of the ucontext we don't use.  */
340     memset(uc, 0, offsetof(struct target_ucontext_v2, tuc_mcontext));
341 
342     memset(&stack, 0, sizeof(stack));
343     target_save_altstack(&stack, env);
344     memcpy(&uc->tuc_stack, &stack, sizeof(stack));
345 
346     setup_sigcontext(&uc->tuc_mcontext, env, set->sig[0]);
347     /* Save coprocessor signal frame.  */
348     regspace = uc->tuc_regspace;
349     if (arm_feature(env, ARM_FEATURE_VFP)) {
350         regspace = setup_sigframe_v2_vfp(regspace, env);
351     }
352     if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
353         regspace = setup_sigframe_v2_iwmmxt(regspace, env);
354     }
355 
356     /* Write terminating magic word */
357     __put_user(0, regspace);
358 
359     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
360         __put_user(set->sig[i], &uc->tuc_sigmask.sig[i]);
361     }
362 }
363 
364 /* compare linux/arch/arm/kernel/signal.c:setup_frame() */
setup_frame_v1(int usig,struct target_sigaction * ka,target_sigset_t * set,CPUARMState * regs)365 static void setup_frame_v1(int usig, struct target_sigaction *ka,
366                            target_sigset_t *set, CPUARMState *regs)
367 {
368     struct sigframe_v1 *frame;
369     abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
370     int i;
371 
372     trace_user_setup_frame(regs, frame_addr);
373     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
374         goto sigsegv;
375     }
376 
377     setup_sigcontext(&frame->sc, regs, set->sig[0]);
378 
379     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
380         __put_user(set->sig[i], &frame->extramask[i - 1]);
381     }
382 
383     if (setup_return(regs, ka, frame->retcode, frame_addr, usig,
384                      frame_addr + offsetof(struct sigframe_v1, retcode))) {
385         goto sigsegv;
386     }
387 
388     unlock_user_struct(frame, frame_addr, 1);
389     return;
390 sigsegv:
391     unlock_user_struct(frame, frame_addr, 1);
392     force_sigsegv(usig);
393 }
394 
setup_frame_v2(int usig,struct target_sigaction * ka,target_sigset_t * set,CPUARMState * regs)395 static void setup_frame_v2(int usig, struct target_sigaction *ka,
396                            target_sigset_t *set, CPUARMState *regs)
397 {
398     struct sigframe_v2 *frame;
399     abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
400 
401     trace_user_setup_frame(regs, frame_addr);
402     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
403         goto sigsegv;
404     }
405 
406     setup_sigframe_v2(&frame->uc, set, regs);
407 
408     if (setup_return(regs, ka, frame->retcode, frame_addr, usig,
409                      frame_addr + offsetof(struct sigframe_v2, retcode))) {
410         goto sigsegv;
411     }
412 
413     unlock_user_struct(frame, frame_addr, 1);
414     return;
415 sigsegv:
416     unlock_user_struct(frame, frame_addr, 1);
417     force_sigsegv(usig);
418 }
419 
setup_frame(int usig,struct target_sigaction * ka,target_sigset_t * set,CPUARMState * regs)420 void setup_frame(int usig, struct target_sigaction *ka,
421                  target_sigset_t *set, CPUARMState *regs)
422 {
423     if (get_osversion() >= 0x020612) {
424         setup_frame_v2(usig, ka, set, regs);
425     } else {
426         setup_frame_v1(usig, ka, set, regs);
427     }
428 }
429 
430 /* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */
setup_rt_frame_v1(int usig,struct target_sigaction * ka,target_siginfo_t * info,target_sigset_t * set,CPUARMState * env)431 static void setup_rt_frame_v1(int usig, struct target_sigaction *ka,
432                               target_siginfo_t *info,
433                               target_sigset_t *set, CPUARMState *env)
434 {
435     struct rt_sigframe_v1 *frame;
436     abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
437     struct target_sigaltstack stack;
438     int i;
439     abi_ulong info_addr, uc_addr;
440 
441     trace_user_setup_rt_frame(env, frame_addr);
442     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
443         goto sigsegv;
444     }
445 
446     info_addr = frame_addr + offsetof(struct rt_sigframe_v1, info);
447     __put_user(info_addr, &frame->pinfo);
448     uc_addr = frame_addr + offsetof(struct rt_sigframe_v1, uc);
449     __put_user(uc_addr, &frame->puc);
450     tswap_siginfo(&frame->info, info);
451 
452     /* Clear all the bits of the ucontext we don't use.  */
453     memset(&frame->uc, 0, offsetof(struct target_ucontext_v1, tuc_mcontext));
454 
455     memset(&stack, 0, sizeof(stack));
456     target_save_altstack(&stack, env);
457     memcpy(&frame->uc.tuc_stack, &stack, sizeof(stack));
458 
459     setup_sigcontext(&frame->uc.tuc_mcontext, env, set->sig[0]);
460     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
461         __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
462     }
463 
464     if (setup_return(env, ka, frame->retcode, frame_addr, usig,
465                      frame_addr + offsetof(struct rt_sigframe_v1, retcode))) {
466         goto sigsegv;
467     }
468 
469     env->regs[1] = info_addr;
470     env->regs[2] = uc_addr;
471 
472     unlock_user_struct(frame, frame_addr, 1);
473     return;
474 sigsegv:
475     unlock_user_struct(frame, frame_addr, 1);
476     force_sigsegv(usig);
477 }
478 
setup_rt_frame_v2(int usig,struct target_sigaction * ka,target_siginfo_t * info,target_sigset_t * set,CPUARMState * env)479 static void setup_rt_frame_v2(int usig, struct target_sigaction *ka,
480                               target_siginfo_t *info,
481                               target_sigset_t *set, CPUARMState *env)
482 {
483     struct rt_sigframe_v2 *frame;
484     abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
485     abi_ulong info_addr, uc_addr;
486 
487     trace_user_setup_rt_frame(env, frame_addr);
488     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
489         goto sigsegv;
490     }
491 
492     info_addr = frame_addr + offsetof(struct rt_sigframe_v2, info);
493     uc_addr = frame_addr + offsetof(struct rt_sigframe_v2, uc);
494     tswap_siginfo(&frame->info, info);
495 
496     setup_sigframe_v2(&frame->uc, set, env);
497 
498     if (setup_return(env, ka, frame->retcode, frame_addr, usig,
499                      frame_addr + offsetof(struct rt_sigframe_v2, retcode))) {
500         goto sigsegv;
501     }
502 
503     env->regs[1] = info_addr;
504     env->regs[2] = uc_addr;
505 
506     unlock_user_struct(frame, frame_addr, 1);
507     return;
508 sigsegv:
509     unlock_user_struct(frame, frame_addr, 1);
510     force_sigsegv(usig);
511 }
512 
setup_rt_frame(int usig,struct target_sigaction * ka,target_siginfo_t * info,target_sigset_t * set,CPUARMState * env)513 void setup_rt_frame(int usig, struct target_sigaction *ka,
514                     target_siginfo_t *info,
515                     target_sigset_t *set, CPUARMState *env)
516 {
517     if (get_osversion() >= 0x020612) {
518         setup_rt_frame_v2(usig, ka, info, set, env);
519     } else {
520         setup_rt_frame_v1(usig, ka, info, set, env);
521     }
522 }
523 
524 static int
restore_sigcontext(CPUARMState * env,struct target_sigcontext * sc)525 restore_sigcontext(CPUARMState *env, struct target_sigcontext *sc)
526 {
527     int err = 0;
528     uint32_t cpsr;
529 
530     __get_user(env->regs[0], &sc->arm_r0);
531     __get_user(env->regs[1], &sc->arm_r1);
532     __get_user(env->regs[2], &sc->arm_r2);
533     __get_user(env->regs[3], &sc->arm_r3);
534     __get_user(env->regs[4], &sc->arm_r4);
535     __get_user(env->regs[5], &sc->arm_r5);
536     __get_user(env->regs[6], &sc->arm_r6);
537     __get_user(env->regs[7], &sc->arm_r7);
538     __get_user(env->regs[8], &sc->arm_r8);
539     __get_user(env->regs[9], &sc->arm_r9);
540     __get_user(env->regs[10], &sc->arm_r10);
541     __get_user(env->regs[11], &sc->arm_fp);
542     __get_user(env->regs[12], &sc->arm_ip);
543     __get_user(env->regs[13], &sc->arm_sp);
544     __get_user(env->regs[14], &sc->arm_lr);
545     __get_user(env->regs[15], &sc->arm_pc);
546 #ifdef TARGET_CONFIG_CPU_32
547     __get_user(cpsr, &sc->arm_cpsr);
548     cpsr_write(env, cpsr, CPSR_USER | CPSR_EXEC, CPSRWriteByInstr);
549 #endif
550 
551     err |= !valid_user_regs(env);
552 
553     return err;
554 }
555 
do_sigreturn_v1(CPUARMState * env)556 static long do_sigreturn_v1(CPUARMState *env)
557 {
558     abi_ulong frame_addr;
559     struct sigframe_v1 *frame = NULL;
560     target_sigset_t set;
561     sigset_t host_set;
562     int i;
563 
564     /*
565      * Since we stacked the signal on a 64-bit boundary,
566      * then 'sp' should be word aligned here.  If it's
567      * not, then the user is trying to mess with us.
568      */
569     frame_addr = env->regs[13];
570     trace_user_do_sigreturn(env, frame_addr);
571     if (frame_addr & 7) {
572         goto badframe;
573     }
574 
575     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
576         goto badframe;
577     }
578 
579     __get_user(set.sig[0], &frame->sc.oldmask);
580     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
581         __get_user(set.sig[i], &frame->extramask[i - 1]);
582     }
583 
584     target_to_host_sigset_internal(&host_set, &set);
585     set_sigmask(&host_set);
586 
587     if (restore_sigcontext(env, &frame->sc)) {
588         goto badframe;
589     }
590 
591 #if 0
592     /* Send SIGTRAP if we're single-stepping */
593     if (ptrace_cancel_bpt(current))
594         send_sig(SIGTRAP, current, 1);
595 #endif
596     unlock_user_struct(frame, frame_addr, 0);
597     return -TARGET_QEMU_ESIGRETURN;
598 
599 badframe:
600     force_sig(TARGET_SIGSEGV);
601     return -TARGET_QEMU_ESIGRETURN;
602 }
603 
restore_sigframe_v2_vfp(CPUARMState * env,abi_ulong * regspace)604 static abi_ulong *restore_sigframe_v2_vfp(CPUARMState *env, abi_ulong *regspace)
605 {
606     int i;
607     abi_ulong magic, sz;
608     uint32_t fpscr, fpexc;
609     struct target_vfp_sigframe *vfpframe;
610     vfpframe = (struct target_vfp_sigframe *)regspace;
611 
612     __get_user(magic, &vfpframe->magic);
613     __get_user(sz, &vfpframe->size);
614     if (magic != TARGET_VFP_MAGIC || sz != sizeof(*vfpframe)) {
615         return 0;
616     }
617     for (i = 0; i < 32; i++) {
618         __get_user(*aa32_vfp_dreg(env, i), &vfpframe->ufp.fpregs[i]);
619     }
620     __get_user(fpscr, &vfpframe->ufp.fpscr);
621     vfp_set_fpscr(env, fpscr);
622     __get_user(fpexc, &vfpframe->ufp_exc.fpexc);
623     /* Sanitise FPEXC: ensure VFP is enabled, FPINST2 is invalid
624      * and the exception flag is cleared
625      */
626     fpexc |= (1 << 30);
627     fpexc &= ~((1 << 31) | (1 << 28));
628     env->vfp.xregs[ARM_VFP_FPEXC] = fpexc;
629     __get_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst);
630     __get_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2);
631     return (abi_ulong*)(vfpframe + 1);
632 }
633 
restore_sigframe_v2_iwmmxt(CPUARMState * env,abi_ulong * regspace)634 static abi_ulong *restore_sigframe_v2_iwmmxt(CPUARMState *env,
635                                              abi_ulong *regspace)
636 {
637     int i;
638     abi_ulong magic, sz;
639     struct target_iwmmxt_sigframe *iwmmxtframe;
640     iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace;
641 
642     __get_user(magic, &iwmmxtframe->magic);
643     __get_user(sz, &iwmmxtframe->size);
644     if (magic != TARGET_IWMMXT_MAGIC || sz != sizeof(*iwmmxtframe)) {
645         return 0;
646     }
647     for (i = 0; i < 16; i++) {
648         __get_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]);
649     }
650     __get_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf);
651     __get_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf);
652     __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0);
653     __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1);
654     __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2);
655     __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3);
656     return (abi_ulong*)(iwmmxtframe + 1);
657 }
658 
do_sigframe_return_v2(CPUARMState * env,target_ulong context_addr,struct target_ucontext_v2 * uc)659 static int do_sigframe_return_v2(CPUARMState *env,
660                                  target_ulong context_addr,
661                                  struct target_ucontext_v2 *uc)
662 {
663     sigset_t host_set;
664     abi_ulong *regspace;
665 
666     target_to_host_sigset(&host_set, &uc->tuc_sigmask);
667     set_sigmask(&host_set);
668 
669     if (restore_sigcontext(env, &uc->tuc_mcontext))
670         return 1;
671 
672     /* Restore coprocessor signal frame */
673     regspace = uc->tuc_regspace;
674     if (arm_feature(env, ARM_FEATURE_VFP)) {
675         regspace = restore_sigframe_v2_vfp(env, regspace);
676         if (!regspace) {
677             return 1;
678         }
679     }
680     if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
681         regspace = restore_sigframe_v2_iwmmxt(env, regspace);
682         if (!regspace) {
683             return 1;
684         }
685     }
686 
687     if (do_sigaltstack(context_addr
688                        + offsetof(struct target_ucontext_v2, tuc_stack),
689                        0, get_sp_from_cpustate(env)) == -EFAULT) {
690         return 1;
691     }
692 
693 #if 0
694     /* Send SIGTRAP if we're single-stepping */
695     if (ptrace_cancel_bpt(current))
696         send_sig(SIGTRAP, current, 1);
697 #endif
698 
699     return 0;
700 }
701 
do_sigreturn_v2(CPUARMState * env)702 static long do_sigreturn_v2(CPUARMState *env)
703 {
704     abi_ulong frame_addr;
705     struct sigframe_v2 *frame = NULL;
706 
707     /*
708      * Since we stacked the signal on a 64-bit boundary,
709      * then 'sp' should be word aligned here.  If it's
710      * not, then the user is trying to mess with us.
711      */
712     frame_addr = env->regs[13];
713     trace_user_do_sigreturn(env, frame_addr);
714     if (frame_addr & 7) {
715         goto badframe;
716     }
717 
718     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
719         goto badframe;
720     }
721 
722     if (do_sigframe_return_v2(env,
723                               frame_addr
724                               + offsetof(struct sigframe_v2, uc),
725                               &frame->uc)) {
726         goto badframe;
727     }
728 
729     unlock_user_struct(frame, frame_addr, 0);
730     return -TARGET_QEMU_ESIGRETURN;
731 
732 badframe:
733     unlock_user_struct(frame, frame_addr, 0);
734     force_sig(TARGET_SIGSEGV);
735     return -TARGET_QEMU_ESIGRETURN;
736 }
737 
do_sigreturn(CPUARMState * env)738 long do_sigreturn(CPUARMState *env)
739 {
740     if (get_osversion() >= 0x020612) {
741         return do_sigreturn_v2(env);
742     } else {
743         return do_sigreturn_v1(env);
744     }
745 }
746 
do_rt_sigreturn_v1(CPUARMState * env)747 static long do_rt_sigreturn_v1(CPUARMState *env)
748 {
749     abi_ulong frame_addr;
750     struct rt_sigframe_v1 *frame = NULL;
751     sigset_t host_set;
752 
753     /*
754      * Since we stacked the signal on a 64-bit boundary,
755      * then 'sp' should be word aligned here.  If it's
756      * not, then the user is trying to mess with us.
757      */
758     frame_addr = env->regs[13];
759     trace_user_do_rt_sigreturn(env, frame_addr);
760     if (frame_addr & 7) {
761         goto badframe;
762     }
763 
764     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
765         goto badframe;
766     }
767 
768     target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask);
769     set_sigmask(&host_set);
770 
771     if (restore_sigcontext(env, &frame->uc.tuc_mcontext)) {
772         goto badframe;
773     }
774 
775     if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe_v1, uc.tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
776         goto badframe;
777 
778 #if 0
779     /* Send SIGTRAP if we're single-stepping */
780     if (ptrace_cancel_bpt(current))
781         send_sig(SIGTRAP, current, 1);
782 #endif
783     unlock_user_struct(frame, frame_addr, 0);
784     return -TARGET_QEMU_ESIGRETURN;
785 
786 badframe:
787     unlock_user_struct(frame, frame_addr, 0);
788     force_sig(TARGET_SIGSEGV);
789     return -TARGET_QEMU_ESIGRETURN;
790 }
791 
do_rt_sigreturn_v2(CPUARMState * env)792 static long do_rt_sigreturn_v2(CPUARMState *env)
793 {
794     abi_ulong frame_addr;
795     struct rt_sigframe_v2 *frame = NULL;
796 
797     /*
798      * Since we stacked the signal on a 64-bit boundary,
799      * then 'sp' should be word aligned here.  If it's
800      * not, then the user is trying to mess with us.
801      */
802     frame_addr = env->regs[13];
803     trace_user_do_rt_sigreturn(env, frame_addr);
804     if (frame_addr & 7) {
805         goto badframe;
806     }
807 
808     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
809         goto badframe;
810     }
811 
812     if (do_sigframe_return_v2(env,
813                               frame_addr
814                               + offsetof(struct rt_sigframe_v2, uc),
815                               &frame->uc)) {
816         goto badframe;
817     }
818 
819     unlock_user_struct(frame, frame_addr, 0);
820     return -TARGET_QEMU_ESIGRETURN;
821 
822 badframe:
823     unlock_user_struct(frame, frame_addr, 0);
824     force_sig(TARGET_SIGSEGV);
825     return -TARGET_QEMU_ESIGRETURN;
826 }
827 
do_rt_sigreturn(CPUARMState * env)828 long do_rt_sigreturn(CPUARMState *env)
829 {
830     if (get_osversion() >= 0x020612) {
831         return do_rt_sigreturn_v2(env);
832     } else {
833         return do_rt_sigreturn_v1(env);
834     }
835 }
836