?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
CPU specific boot mode (Robert Reif)
[qemu/qemu_0_9_1_stable.git] / linux-user / signal.c
blob0c5944abab917cf9a0f17d3b305ae6f3cb30698a
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, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20 #include <stdlib.h>
21 #include <stdio.h>
22 #include <string.h>
23 #include <stdarg.h>
24 #include <unistd.h>
25 #include <signal.h>
26 #include <errno.h>
27 #include <sys/ucontext.h>
28
29 #include "qemu.h"
30 #include "target_signal.h"
31
32 //#define DEBUG_SIGNAL
33
34 #define MAX_SIGQUEUE_SIZE 1024
35
36 struct sigqueue {
37 struct sigqueue *next;
38 target_siginfo_t info;
39 };
40
41 struct emulated_sigaction {
42 struct target_sigaction sa;
43 int pending; /* true if signal is pending */
44 struct sigqueue *first;
45 struct sigqueue info; /* in order to always have memory for the
46 first signal, we put it here */
47 };
48
49 struct target_sigaltstack target_sigaltstack_used = {
50 .ss_sp = 0,
51 .ss_size = 0,
52 .ss_flags = TARGET_SS_DISABLE,
53 };
54
55 static struct emulated_sigaction sigact_table[TARGET_NSIG];
56 static struct sigqueue sigqueue_table[MAX_SIGQUEUE_SIZE]; /* siginfo queue */
57 static struct sigqueue *first_free; /* first free siginfo queue entry */
58 static int signal_pending; /* non zero if a signal may be pending */
59
60 static void host_signal_handler(int host_signum, siginfo_t *info,
61 void *puc);
62
63 static uint8_t host_to_target_signal_table[65] = {
64 [SIGHUP] = TARGET_SIGHUP,
65 [SIGINT] = TARGET_SIGINT,
66 [SIGQUIT] = TARGET_SIGQUIT,
67 [SIGILL] = TARGET_SIGILL,
68 [SIGTRAP] = TARGET_SIGTRAP,
69 [SIGABRT] = TARGET_SIGABRT,
70 /* [SIGIOT] = TARGET_SIGIOT,*/
71 [SIGBUS] = TARGET_SIGBUS,
72 [SIGFPE] = TARGET_SIGFPE,
73 [SIGKILL] = TARGET_SIGKILL,
74 [SIGUSR1] = TARGET_SIGUSR1,
75 [SIGSEGV] = TARGET_SIGSEGV,
76 [SIGUSR2] = TARGET_SIGUSR2,
77 [SIGPIPE] = TARGET_SIGPIPE,
78 [SIGALRM] = TARGET_SIGALRM,
79 [SIGTERM] = TARGET_SIGTERM,
80 #ifdef SIGSTKFLT
81 [SIGSTKFLT] = TARGET_SIGSTKFLT,
82 #endif
83 [SIGCHLD] = TARGET_SIGCHLD,
84 [SIGCONT] = TARGET_SIGCONT,
85 [SIGSTOP] = TARGET_SIGSTOP,
86 [SIGTSTP] = TARGET_SIGTSTP,
87 [SIGTTIN] = TARGET_SIGTTIN,
88 [SIGTTOU] = TARGET_SIGTTOU,
89 [SIGURG] = TARGET_SIGURG,
90 [SIGXCPU] = TARGET_SIGXCPU,
91 [SIGXFSZ] = TARGET_SIGXFSZ,
92 [SIGVTALRM] = TARGET_SIGVTALRM,
93 [SIGPROF] = TARGET_SIGPROF,
94 [SIGWINCH] = TARGET_SIGWINCH,
95 [SIGIO] = TARGET_SIGIO,
96 [SIGPWR] = TARGET_SIGPWR,
97 [SIGSYS] = TARGET_SIGSYS,
98 /* next signals stay the same */
99 };
100 static uint8_t target_to_host_signal_table[65];
101
102 static inline int on_sig_stack(unsigned long sp)
103 {
104 return (sp - target_sigaltstack_used.ss_sp
105 < target_sigaltstack_used.ss_size);
106 }
107
108 static inline int sas_ss_flags(unsigned long sp)
109 {
110 return (target_sigaltstack_used.ss_size == 0 ? SS_DISABLE
111 : on_sig_stack(sp) ? SS_ONSTACK : 0);
112 }
113
114 static inline int host_to_target_signal(int sig)
115 {
116 return host_to_target_signal_table[sig];
117 }
118
119 static inline int target_to_host_signal(int sig)
120 {
121 return target_to_host_signal_table[sig];
122 }
123
124 static void host_to_target_sigset_internal(target_sigset_t *d,
125 const sigset_t *s)
126 {
127 int i;
128 unsigned long sigmask;
129 uint32_t target_sigmask;
130
131 sigmask = ((unsigned long *)s)[0];
132 target_sigmask = 0;
133 for(i = 0; i < 32; i++) {
134 if (sigmask & (1 << i))
135 target_sigmask |= 1 << (host_to_target_signal(i + 1) - 1);
136 }
137 #if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 32
138 d->sig[0] = target_sigmask;
139 for(i = 1;i < TARGET_NSIG_WORDS; i++) {
140 d->sig[i] = ((unsigned long *)s)[i];
141 }
142 #elif TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64 && TARGET_NSIG_WORDS == 2
143 d->sig[0] = target_sigmask;
144 d->sig[1] = sigmask >> 32;
145 #else
146 #warning host_to_target_sigset
147 #endif
148 }
149
150 void host_to_target_sigset(target_sigset_t *d, const sigset_t *s)
151 {
152 target_sigset_t d1;
153 int i;
154
155 host_to_target_sigset_internal(&d1, s);
156 for(i = 0;i < TARGET_NSIG_WORDS; i++)
157 d->sig[i] = tswapl(d1.sig[i]);
158 }
159
160 void target_to_host_sigset_internal(sigset_t *d, const target_sigset_t *s)
161 {
162 int i;
163 unsigned long sigmask;
164 abi_ulong target_sigmask;
165
166 target_sigmask = s->sig[0];
167 sigmask = 0;
168 for(i = 0; i < 32; i++) {
169 if (target_sigmask & (1 << i))
170 sigmask |= 1 << (target_to_host_signal(i + 1) - 1);
171 }
172 #if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 32
173 ((unsigned long *)d)[0] = sigmask;
174 for(i = 1;i < TARGET_NSIG_WORDS; i++) {
175 ((unsigned long *)d)[i] = s->sig[i];
176 }
177 #elif TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64 && TARGET_NSIG_WORDS == 2
178 ((unsigned long *)d)[0] = sigmask | ((unsigned long)(s->sig[1]) << 32);
179 #else
180 #warning target_to_host_sigset
181 #endif /* TARGET_ABI_BITS */
182 }
183
184 void target_to_host_sigset(sigset_t *d, const target_sigset_t *s)
185 {
186 target_sigset_t s1;
187 int i;
188
189 for(i = 0;i < TARGET_NSIG_WORDS; i++)
190 s1.sig[i] = tswapl(s->sig[i]);
191 target_to_host_sigset_internal(d, &s1);
192 }
193
194 void host_to_target_old_sigset(abi_ulong *old_sigset,
195 const sigset_t *sigset)
196 {
197 target_sigset_t d;
198 host_to_target_sigset(&d, sigset);
199 *old_sigset = d.sig[0];
200 }
201
202 void target_to_host_old_sigset(sigset_t *sigset,
203 const abi_ulong *old_sigset)
204 {
205 target_sigset_t d;
206 int i;
207
208 d.sig[0] = *old_sigset;
209 for(i = 1;i < TARGET_NSIG_WORDS; i++)
210 d.sig[i] = 0;
211 target_to_host_sigset(sigset, &d);
212 }
213
214 /* siginfo conversion */
215
216 static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo,
217 const siginfo_t *info)
218 {
219 int sig;
220 sig = host_to_target_signal(info->si_signo);
221 tinfo->si_signo = sig;
222 tinfo->si_errno = 0;
223 tinfo->si_code = 0;
224 if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
225 sig == SIGBUS || sig == SIGTRAP) {
226 /* should never come here, but who knows. The information for
227 the target is irrelevant */
228 tinfo->_sifields._sigfault._addr = 0;
229 } else if (sig == SIGIO) {
230 tinfo->_sifields._sigpoll._fd = info->si_fd;
231 } else if (sig >= TARGET_SIGRTMIN) {
232 tinfo->_sifields._rt._pid = info->si_pid;
233 tinfo->_sifields._rt._uid = info->si_uid;
234 /* XXX: potential problem if 64 bit */
235 tinfo->_sifields._rt._sigval.sival_ptr =
236 (abi_ulong)info->si_value.sival_ptr;
237 }
238 }
239
240 static void tswap_siginfo(target_siginfo_t *tinfo,
241 const target_siginfo_t *info)
242 {
243 int sig;
244 sig = info->si_signo;
245 tinfo->si_signo = tswap32(sig);
246 tinfo->si_errno = tswap32(info->si_errno);
247 tinfo->si_code = tswap32(info->si_code);
248 if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
249 sig == SIGBUS || sig == SIGTRAP) {
250 tinfo->_sifields._sigfault._addr =
251 tswapl(info->_sifields._sigfault._addr);
252 } else if (sig == SIGIO) {
253 tinfo->_sifields._sigpoll._fd = tswap32(info->_sifields._sigpoll._fd);
254 } else if (sig >= TARGET_SIGRTMIN) {
255 tinfo->_sifields._rt._pid = tswap32(info->_sifields._rt._pid);
256 tinfo->_sifields._rt._uid = tswap32(info->_sifields._rt._uid);
257 tinfo->_sifields._rt._sigval.sival_ptr =
258 tswapl(info->_sifields._rt._sigval.sival_ptr);
259 }
260 }
261
262
263 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
264 {
265 host_to_target_siginfo_noswap(tinfo, info);
266 tswap_siginfo(tinfo, tinfo);
267 }
268
269 /* XXX: we support only POSIX RT signals are used. */
270 /* XXX: find a solution for 64 bit (additional malloced data is needed) */
271 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)
272 {
273 info->si_signo = tswap32(tinfo->si_signo);
274 info->si_errno = tswap32(tinfo->si_errno);
275 info->si_code = tswap32(tinfo->si_code);
276 info->si_pid = tswap32(tinfo->_sifields._rt._pid);
277 info->si_uid = tswap32(tinfo->_sifields._rt._uid);
278 info->si_value.sival_ptr =
279 (void *)tswapl(tinfo->_sifields._rt._sigval.sival_ptr);
280 }
281
282 void signal_init(void)
283 {
284 struct sigaction act;
285 int i, j;
286
287 /* generate signal conversion tables */
288 for(i = 1; i <= 64; i++) {
289 if (host_to_target_signal_table[i] == 0)
290 host_to_target_signal_table[i] = i;
291 }
292 for(i = 1; i <= 64; i++) {
293 j = host_to_target_signal_table[i];
294 target_to_host_signal_table[j] = i;
295 }
296
297 /* set all host signal handlers. ALL signals are blocked during
298 the handlers to serialize them. */
299 sigfillset(&act.sa_mask);
300 act.sa_flags = SA_SIGINFO;
301 act.sa_sigaction = host_signal_handler;
302 for(i = 1; i < NSIG; i++) {
303 sigaction(i, &act, NULL);
304 }
305
306 memset(sigact_table, 0, sizeof(sigact_table));
307
308 first_free = &sigqueue_table[0];
309 for(i = 0; i < MAX_SIGQUEUE_SIZE - 1; i++)
310 sigqueue_table[i].next = &sigqueue_table[i + 1];
311 sigqueue_table[MAX_SIGQUEUE_SIZE - 1].next = NULL;
312 }
313
314 /* signal queue handling */
315
316 static inline struct sigqueue *alloc_sigqueue(void)
317 {
318 struct sigqueue *q = first_free;
319 if (!q)
320 return NULL;
321 first_free = q->next;
322 return q;
323 }
324
325 static inline void free_sigqueue(struct sigqueue *q)
326 {
327 q->next = first_free;
328 first_free = q;
329 }
330
331 /* abort execution with signal */
332 void __attribute((noreturn)) force_sig(int sig)
333 {
334 int host_sig;
335 host_sig = target_to_host_signal(sig);
336 fprintf(stderr, "qemu: uncaught target signal %d (%s) - exiting\n",
337 sig, strsignal(host_sig));
338 #if 1
339 _exit(-host_sig);
340 #else
341 {
342 struct sigaction act;
343 sigemptyset(&act.sa_mask);
344 act.sa_flags = SA_SIGINFO;
345 act.sa_sigaction = SIG_DFL;
346 sigaction(SIGABRT, &act, NULL);
347 abort();
348 }
349 #endif
350 }
351
352 /* queue a signal so that it will be send to the virtual CPU as soon
353 as possible */
354 int queue_signal(int sig, target_siginfo_t *info)
355 {
356 struct emulated_sigaction *k;
357 struct sigqueue *q, **pq;
358 abi_ulong handler;
359
360 #if defined(DEBUG_SIGNAL)
361 fprintf(stderr, "queue_signal: sig=%d\n",
362 sig);
363 #endif
364 k = &sigact_table[sig - 1];
365 handler = k->sa._sa_handler;
366 if (handler == TARGET_SIG_DFL) {
367 /* default handler : ignore some signal. The other are fatal */
368 if (sig != TARGET_SIGCHLD &&
369 sig != TARGET_SIGURG &&
370 sig != TARGET_SIGWINCH) {
371 force_sig(sig);
372 } else {
373 return 0; /* indicate ignored */
374 }
375 } else if (handler == TARGET_SIG_IGN) {
376 /* ignore signal */
377 return 0;
378 } else if (handler == TARGET_SIG_ERR) {
379 force_sig(sig);
380 } else {
381 pq = &k->first;
382 if (sig < TARGET_SIGRTMIN) {
383 /* if non real time signal, we queue exactly one signal */
384 if (!k->pending)
385 q = &k->info;
386 else
387 return 0;
388 } else {
389 if (!k->pending) {
390 /* first signal */
391 q = &k->info;
392 } else {
393 q = alloc_sigqueue();
394 if (!q)
395 return -EAGAIN;
396 while (*pq != NULL)
397 pq = &(*pq)->next;
398 }
399 }
400 *pq = q;
401 q->info = *info;
402 q->next = NULL;
403 k->pending = 1;
404 /* signal that a new signal is pending */
405 signal_pending = 1;
406 return 1; /* indicates that the signal was queued */
407 }
408 }
409
410 static void host_signal_handler(int host_signum, siginfo_t *info,
411 void *puc)
412 {
413 int sig;
414 target_siginfo_t tinfo;
415
416 /* the CPU emulator uses some host signals to detect exceptions,
417 we we forward to it some signals */
418 if (host_signum == SIGSEGV || host_signum == SIGBUS
419 #if defined(TARGET_I386) && defined(USE_CODE_COPY)
420 || host_signum == SIGFPE
421 #endif
422 ) {
423 if (cpu_signal_handler(host_signum, info, puc))
424 return;
425 }
426
427 /* get target signal number */
428 sig = host_to_target_signal(host_signum);
429 if (sig < 1 || sig > TARGET_NSIG)
430 return;
431 #if defined(DEBUG_SIGNAL)
432 fprintf(stderr, "qemu: got signal %d\n", sig);
433 #endif
434 host_to_target_siginfo_noswap(&tinfo, info);
435 if (queue_signal(sig, &tinfo) == 1) {
436 /* interrupt the virtual CPU as soon as possible */
437 cpu_interrupt(global_env, CPU_INTERRUPT_EXIT);
438 }
439 }
440
441 /* do_sigaltstack() returns target values and errnos. */
442 int do_sigaltstack(const struct target_sigaltstack *uss,
443 struct target_sigaltstack *uoss,
444 abi_ulong sp)
445 {
446 int ret;
447 struct target_sigaltstack oss;
448
449 /* XXX: test errors */
450 if(uoss)
451 {
452 __put_user(target_sigaltstack_used.ss_sp, &oss.ss_sp);
453 __put_user(target_sigaltstack_used.ss_size, &oss.ss_size);
454 __put_user(sas_ss_flags(sp), &oss.ss_flags);
455 }
456
457 if(uss)
458 {
459 struct target_sigaltstack ss;
460
461 ret = -TARGET_EFAULT;
462 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
463 || __get_user(ss.ss_sp, &uss->ss_sp)
464 || __get_user(ss.ss_size, &uss->ss_size)
465 || __get_user(ss.ss_flags, &uss->ss_flags))
466 goto out;
467
468 ret = -TARGET_EPERM;
469 if (on_sig_stack(sp))
470 goto out;
471
472 ret = -TARGET_EINVAL;
473 if (ss.ss_flags != TARGET_SS_DISABLE
474 && ss.ss_flags != TARGET_SS_ONSTACK
475 && ss.ss_flags != 0)
476 goto out;
477
478 if (ss.ss_flags == TARGET_SS_DISABLE) {
479 ss.ss_size = 0;
480 ss.ss_sp = 0;
481 } else {
482 ret = -TARGET_ENOMEM;
483 if (ss.ss_size < MINSIGSTKSZ)
484 goto out;
485 }
486
487 target_sigaltstack_used.ss_sp = ss.ss_sp;
488 target_sigaltstack_used.ss_size = ss.ss_size;
489 }
490
491 if (uoss) {
492 ret = -TARGET_EFAULT;
493 if (!access_ok(VERIFY_WRITE, uoss, sizeof(oss)))
494 goto out;
495 memcpy(uoss, &oss, sizeof(oss));
496 }
497
498 ret = 0;
499 out:
500 return ret;
501 }
502
503 /* do_sigaction() return host values and errnos */
504 int do_sigaction(int sig, const struct target_sigaction *act,
505 struct target_sigaction *oact)
506 {
507 struct emulated_sigaction *k;
508 struct sigaction act1;
509 int host_sig;
510 int ret = 0;
511
512 if (sig < 1 || sig > TARGET_NSIG || sig == SIGKILL || sig == SIGSTOP)
513 return -EINVAL;
514 k = &sigact_table[sig - 1];
515 #if defined(DEBUG_SIGNAL)
516 fprintf(stderr, "sigaction sig=%d act=0x%08x, oact=0x%08x\n",
517 sig, (int)act, (int)oact);
518 #endif
519 if (oact) {
520 oact->_sa_handler = tswapl(k->sa._sa_handler);
521 oact->sa_flags = tswapl(k->sa.sa_flags);
522 #if !defined(TARGET_MIPS)
523 oact->sa_restorer = tswapl(k->sa.sa_restorer);
524 #endif
525 oact->sa_mask = k->sa.sa_mask;
526 }
527 if (act) {
528 k->sa._sa_handler = tswapl(act->_sa_handler);
529 k->sa.sa_flags = tswapl(act->sa_flags);
530 #if !defined(TARGET_MIPS)
531 k->sa.sa_restorer = tswapl(act->sa_restorer);
532 #endif
533 k->sa.sa_mask = act->sa_mask;
534
535 /* we update the host linux signal state */
536 host_sig = target_to_host_signal(sig);
537 if (host_sig != SIGSEGV && host_sig != SIGBUS) {
538 sigfillset(&act1.sa_mask);
539 act1.sa_flags = SA_SIGINFO;
540 if (k->sa.sa_flags & TARGET_SA_RESTART)
541 act1.sa_flags |= SA_RESTART;
542 /* NOTE: it is important to update the host kernel signal
543 ignore state to avoid getting unexpected interrupted
544 syscalls */
545 if (k->sa._sa_handler == TARGET_SIG_IGN) {
546 act1.sa_sigaction = (void *)SIG_IGN;
547 } else if (k->sa._sa_handler == TARGET_SIG_DFL) {
548 act1.sa_sigaction = (void *)SIG_DFL;
549 } else {
550 act1.sa_sigaction = host_signal_handler;
551 }
552 ret = sigaction(host_sig, &act1, NULL);
553 }
554 }
555 return ret;
556 }
557
558 #ifndef offsetof
559 #define offsetof(type, field) ((size_t) &((type *)0)->field)
560 #endif
561
562 static inline int copy_siginfo_to_user(target_siginfo_t *tinfo,
563 const target_siginfo_t *info)
564 {
565 tswap_siginfo(tinfo, info);
566 return 0;
567 }
568
569 #ifdef TARGET_I386
570
571 /* from the Linux kernel */
572
573 struct target_fpreg {
574 uint16_t significand[4];
575 uint16_t exponent;
576 };
577
578 struct target_fpxreg {
579 uint16_t significand[4];
580 uint16_t exponent;
581 uint16_t padding[3];
582 };
583
584 struct target_xmmreg {
585 abi_ulong element[4];
586 };
587
588 struct target_fpstate {
589 /* Regular FPU environment */
590 abi_ulong cw;
591 abi_ulong sw;
592 abi_ulong tag;
593 abi_ulong ipoff;
594 abi_ulong cssel;
595 abi_ulong dataoff;
596 abi_ulong datasel;
597 struct target_fpreg _st[8];
598 uint16_t status;
599 uint16_t magic; /* 0xffff = regular FPU data only */
600
601 /* FXSR FPU environment */
602 abi_ulong _fxsr_env[6]; /* FXSR FPU env is ignored */
603 abi_ulong mxcsr;
604 abi_ulong reserved;
605 struct target_fpxreg _fxsr_st[8]; /* FXSR FPU reg data is ignored */
606 struct target_xmmreg _xmm[8];
607 abi_ulong padding[56];
608 };
609
610 #define X86_FXSR_MAGIC 0x0000
611
612 struct target_sigcontext {
613 uint16_t gs, __gsh;
614 uint16_t fs, __fsh;
615 uint16_t es, __esh;
616 uint16_t ds, __dsh;
617 abi_ulong edi;
618 abi_ulong esi;
619 abi_ulong ebp;
620 abi_ulong esp;
621 abi_ulong ebx;
622 abi_ulong edx;
623 abi_ulong ecx;
624 abi_ulong eax;
625 abi_ulong trapno;
626 abi_ulong err;
627 abi_ulong eip;
628 uint16_t cs, __csh;
629 abi_ulong eflags;
630 abi_ulong esp_at_signal;
631 uint16_t ss, __ssh;
632 abi_ulong fpstate; /* pointer */
633 abi_ulong oldmask;
634 abi_ulong cr2;
635 };
636
637 struct target_ucontext {
638 abi_ulong tuc_flags;
639 abi_ulong tuc_link;
640 target_stack_t tuc_stack;
641 struct target_sigcontext tuc_mcontext;
642 target_sigset_t tuc_sigmask; /* mask last for extensibility */
643 };
644
645 struct sigframe
646 {
647 abi_ulong pretcode;
648 int sig;
649 struct target_sigcontext sc;
650 struct target_fpstate fpstate;
651 abi_ulong extramask[TARGET_NSIG_WORDS-1];
652 char retcode[8];
653 };
654
655 struct rt_sigframe
656 {
657 abi_ulong pretcode;
658 int sig;
659 abi_ulong pinfo;
660 abi_ulong puc;
661 struct target_siginfo info;
662 struct target_ucontext uc;
663 struct target_fpstate fpstate;
664 char retcode[8];
665 };
666
667 /*
668 * Set up a signal frame.
669 */
670
671 /* XXX: save x87 state */
672 static int
673 setup_sigcontext(struct target_sigcontext *sc, struct target_fpstate *fpstate,
674 CPUX86State *env, unsigned long mask)
675 {
676 int err = 0;
677
678 err |= __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs);
679 err |= __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs);
680 err |= __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es);
681 err |= __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds);
682 err |= __put_user(env->regs[R_EDI], &sc->edi);
683 err |= __put_user(env->regs[R_ESI], &sc->esi);
684 err |= __put_user(env->regs[R_EBP], &sc->ebp);
685 err |= __put_user(env->regs[R_ESP], &sc->esp);
686 err |= __put_user(env->regs[R_EBX], &sc->ebx);
687 err |= __put_user(env->regs[R_EDX], &sc->edx);
688 err |= __put_user(env->regs[R_ECX], &sc->ecx);
689 err |= __put_user(env->regs[R_EAX], &sc->eax);
690 err |= __put_user(env->exception_index, &sc->trapno);
691 err |= __put_user(env->error_code, &sc->err);
692 err |= __put_user(env->eip, &sc->eip);
693 err |= __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs);
694 err |= __put_user(env->eflags, &sc->eflags);
695 err |= __put_user(env->regs[R_ESP], &sc->esp_at_signal);
696 err |= __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss);
697
698 cpu_x86_fsave(env, (void *)fpstate, 1);
699 fpstate->status = fpstate->sw;
700 err |= __put_user(0xffff, &fpstate->magic);
701 err |= __put_user(fpstate, &sc->fpstate);
702
703 /* non-iBCS2 extensions.. */
704 err |= __put_user(mask, &sc->oldmask);
705 err |= __put_user(env->cr[2], &sc->cr2);
706 return err;
707 }
708
709 /*
710 * Determine which stack to use..
711 */
712
713 static inline void *
714 get_sigframe(struct emulated_sigaction *ka, CPUX86State *env, size_t frame_size)
715 {
716 unsigned long esp;
717
718 /* Default to using normal stack */
719 esp = env->regs[R_ESP];
720 /* This is the X/Open sanctioned signal stack switching. */
721 if (ka->sa.sa_flags & TARGET_SA_ONSTACK) {
722 if (sas_ss_flags(esp) == 0)
723 esp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
724 }
725
726 /* This is the legacy signal stack switching. */
727 else
728 if ((env->segs[R_SS].selector & 0xffff) != __USER_DS &&
729 !(ka->sa.sa_flags & TARGET_SA_RESTORER) &&
730 ka->sa.sa_restorer) {
731 esp = (unsigned long) ka->sa.sa_restorer;
732 }
733 return g2h((esp - frame_size) & -8ul);
734 }
735
736 static void setup_frame(int sig, struct emulated_sigaction *ka,
737 target_sigset_t *set, CPUX86State *env)
738 {
739 struct sigframe *frame;
740 int i, err = 0;
741
742 frame = get_sigframe(ka, env, sizeof(*frame));
743
744 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
745 goto give_sigsegv;
746 err |= __put_user((/*current->exec_domain
747 && current->exec_domain->signal_invmap
748 && sig < 32
749 ? current->exec_domain->signal_invmap[sig]
750 : */ sig),
751 &frame->sig);
752 if (err)
753 goto give_sigsegv;
754
755 setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0]);
756 if (err)
757 goto give_sigsegv;
758
759 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
760 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
761 goto give_sigsegv;
762 }
763
764 /* Set up to return from userspace. If provided, use a stub
765 already in userspace. */
766 if (ka->sa.sa_flags & TARGET_SA_RESTORER) {
767 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
768 } else {
769 err |= __put_user(frame->retcode, &frame->pretcode);
770 /* This is popl %eax ; movl $,%eax ; int $0x80 */
771 err |= __put_user(0xb858, (short *)(frame->retcode+0));
772 #if defined(TARGET_X86_64)
773 #warning "Fix this !"
774 #else
775 err |= __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2));
776 #endif
777 err |= __put_user(0x80cd, (short *)(frame->retcode+6));
778 }
779
780 if (err)
781 goto give_sigsegv;
782
783 /* Set up registers for signal handler */
784 env->regs[R_ESP] = h2g(frame);
785 env->eip = (unsigned long) ka->sa._sa_handler;
786
787 cpu_x86_load_seg(env, R_DS, __USER_DS);
788 cpu_x86_load_seg(env, R_ES, __USER_DS);
789 cpu_x86_load_seg(env, R_SS, __USER_DS);
790 cpu_x86_load_seg(env, R_CS, __USER_CS);
791 env->eflags &= ~TF_MASK;
792
793 return;
794
795 give_sigsegv:
796 if (sig == TARGET_SIGSEGV)
797 ka->sa._sa_handler = TARGET_SIG_DFL;
798 force_sig(TARGET_SIGSEGV /* , current */);
799 }
800
801 static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
802 target_siginfo_t *info,
803 target_sigset_t *set, CPUX86State *env)
804 {
805 struct rt_sigframe *frame;
806 int i, err = 0;
807
808 frame = get_sigframe(ka, env, sizeof(*frame));
809
810 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
811 goto give_sigsegv;
812
813 err |= __put_user((/*current->exec_domain
814 && current->exec_domain->signal_invmap
815 && sig < 32
816 ? current->exec_domain->signal_invmap[sig]
817 : */sig),
818 &frame->sig);
819 err |= __put_user((abi_ulong)&frame->info, &frame->pinfo);
820 err |= __put_user((abi_ulong)&frame->uc, &frame->puc);
821 err |= copy_siginfo_to_user(&frame->info, info);
822 if (err)
823 goto give_sigsegv;
824
825 /* Create the ucontext. */
826 err |= __put_user(0, &frame->uc.tuc_flags);
827 err |= __put_user(0, &frame->uc.tuc_link);
828 err |= __put_user(target_sigaltstack_used.ss_sp,
829 &frame->uc.tuc_stack.ss_sp);
830 err |= __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
831 &frame->uc.tuc_stack.ss_flags);
832 err |= __put_user(target_sigaltstack_used.ss_size,
833 &frame->uc.tuc_stack.ss_size);
834 err |= setup_sigcontext(&frame->uc.tuc_mcontext, &frame->fpstate,
835 env, set->sig[0]);
836 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
837 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
838 goto give_sigsegv;
839 }
840
841 /* Set up to return from userspace. If provided, use a stub
842 already in userspace. */
843 if (ka->sa.sa_flags & TARGET_SA_RESTORER) {
844 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
845 } else {
846 err |= __put_user(frame->retcode, &frame->pretcode);
847 /* This is movl $,%eax ; int $0x80 */
848 err |= __put_user(0xb8, (char *)(frame->retcode+0));
849 err |= __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1));
850 err |= __put_user(0x80cd, (short *)(frame->retcode+5));
851 }
852
853 if (err)
854 goto give_sigsegv;
855
856 /* Set up registers for signal handler */
857 env->regs[R_ESP] = (unsigned long) frame;
858 env->eip = (unsigned long) ka->sa._sa_handler;
859
860 cpu_x86_load_seg(env, R_DS, __USER_DS);
861 cpu_x86_load_seg(env, R_ES, __USER_DS);
862 cpu_x86_load_seg(env, R_SS, __USER_DS);
863 cpu_x86_load_seg(env, R_CS, __USER_CS);
864 env->eflags &= ~TF_MASK;
865
866 return;
867
868 give_sigsegv:
869 if (sig == TARGET_SIGSEGV)
870 ka->sa._sa_handler = TARGET_SIG_DFL;
871 force_sig(TARGET_SIGSEGV /* , current */);
872 }
873
874 static int
875 restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc, int *peax)
876 {
877 unsigned int err = 0;
878
879 cpu_x86_load_seg(env, R_GS, lduw(&sc->gs));
880 cpu_x86_load_seg(env, R_FS, lduw(&sc->fs));
881 cpu_x86_load_seg(env, R_ES, lduw(&sc->es));
882 cpu_x86_load_seg(env, R_DS, lduw(&sc->ds));
883
884 env->regs[R_EDI] = ldl(&sc->edi);
885 env->regs[R_ESI] = ldl(&sc->esi);
886 env->regs[R_EBP] = ldl(&sc->ebp);
887 env->regs[R_ESP] = ldl(&sc->esp);
888 env->regs[R_EBX] = ldl(&sc->ebx);
889 env->regs[R_EDX] = ldl(&sc->edx);
890 env->regs[R_ECX] = ldl(&sc->ecx);
891 env->eip = ldl(&sc->eip);
892
893 cpu_x86_load_seg(env, R_CS, lduw(&sc->cs) | 3);
894 cpu_x86_load_seg(env, R_SS, lduw(&sc->ss) | 3);
895
896 {
897 unsigned int tmpflags;
898 tmpflags = ldl(&sc->eflags);
899 env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
900 // regs->orig_eax = -1; /* disable syscall checks */
901 }
902
903 {
904 struct _fpstate * buf;
905 buf = (void *)ldl(&sc->fpstate);
906 if (buf) {
907 #if 0
908 if (verify_area(VERIFY_READ, buf, sizeof(*buf)))
909 goto badframe;
910 #endif
911 cpu_x86_frstor(env, (void *)buf, 1);
912 }
913 }
914
915 *peax = ldl(&sc->eax);
916 return err;
917 #if 0
918 badframe:
919 return 1;
920 #endif
921 }
922
923 long do_sigreturn(CPUX86State *env)
924 {
925 struct sigframe *frame = (struct sigframe *)g2h(env->regs[R_ESP] - 8);
926 target_sigset_t target_set;
927 sigset_t set;
928 int eax, i;
929
930 #if defined(DEBUG_SIGNAL)
931 fprintf(stderr, "do_sigreturn\n");
932 #endif
933 /* set blocked signals */
934 if (__get_user(target_set.sig[0], &frame->sc.oldmask))
935 goto badframe;
936 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
937 if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
938 goto badframe;
939 }
940
941 target_to_host_sigset_internal(&set, &target_set);
942 sigprocmask(SIG_SETMASK, &set, NULL);
943
944 /* restore registers */
945 if (restore_sigcontext(env, &frame->sc, &eax))
946 goto badframe;
947 return eax;
948
949 badframe:
950 force_sig(TARGET_SIGSEGV);
951 return 0;
952 }
953
954 long do_rt_sigreturn(CPUX86State *env)
955 {
956 struct rt_sigframe *frame = (struct rt_sigframe *)g2h(env->regs[R_ESP] - 4);
957 sigset_t set;
958 int eax;
959
960 #if 0
961 if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
962 goto badframe;
963 #endif
964 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
965 sigprocmask(SIG_SETMASK, &set, NULL);
966
967 if (restore_sigcontext(env, &frame->uc.tuc_mcontext, &eax))
968 goto badframe;
969
970 if (do_sigaltstack(&frame->uc.tuc_stack, NULL, get_sp_from_cpustate(env)) == -EFAULT)
971 goto badframe;
972
973 return eax;
974
975 badframe:
976 force_sig(TARGET_SIGSEGV);
977 return 0;
978 }
979
980 #elif defined(TARGET_ARM)
981
982 struct target_sigcontext {
983 abi_ulong trap_no;
984 abi_ulong error_code;
985 abi_ulong oldmask;
986 abi_ulong arm_r0;
987 abi_ulong arm_r1;
988 abi_ulong arm_r2;
989 abi_ulong arm_r3;
990 abi_ulong arm_r4;
991 abi_ulong arm_r5;
992 abi_ulong arm_r6;
993 abi_ulong arm_r7;
994 abi_ulong arm_r8;
995 abi_ulong arm_r9;
996 abi_ulong arm_r10;
997 abi_ulong arm_fp;
998 abi_ulong arm_ip;
999 abi_ulong arm_sp;
1000 abi_ulong arm_lr;
1001 abi_ulong arm_pc;
1002 abi_ulong arm_cpsr;
1003 abi_ulong fault_address;
1004 };
1005
1006 struct target_ucontext {
1007 abi_ulong tuc_flags;
1008 abi_ulong tuc_link;
1009 target_stack_t tuc_stack;
1010 struct target_sigcontext tuc_mcontext;
1011 target_sigset_t tuc_sigmask; /* mask last for extensibility */
1012 };
1013
1014 struct sigframe
1015 {
1016 struct target_sigcontext sc;
1017 abi_ulong extramask[TARGET_NSIG_WORDS-1];
1018 abi_ulong retcode;
1019 };
1020
1021 struct rt_sigframe
1022 {
1023 struct target_siginfo *pinfo;
1024 void *puc;
1025 struct target_siginfo info;
1026 struct target_ucontext uc;
1027 abi_ulong retcode;
1028 };
1029
1030 #define TARGET_CONFIG_CPU_32 1
1031
1032 /*
1033 * For ARM syscalls, we encode the syscall number into the instruction.
1034 */
1035 #define SWI_SYS_SIGRETURN (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
1036 #define SWI_SYS_RT_SIGRETURN (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
1037
1038 /*
1039 * For Thumb syscalls, we pass the syscall number via r7. We therefore
1040 * need two 16-bit instructions.
1041 */
1042 #define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
1043 #define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
1044
1045 static const abi_ulong retcodes[4] = {
1046 SWI_SYS_SIGRETURN, SWI_THUMB_SIGRETURN,
1047 SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN
1048 };
1049
1050
1051 #define __put_user_error(x,p,e) __put_user(x, p)
1052 #define __get_user_error(x,p,e) __get_user(x, p)
1053
1054 static inline int valid_user_regs(CPUState *regs)
1055 {
1056 return 1;
1057 }
1058
1059 static int
1060 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1061 CPUState *env, unsigned long mask)
1062 {
1063 int err = 0;
1064
1065 __put_user_error(env->regs[0], &sc->arm_r0, err);
1066 __put_user_error(env->regs[1], &sc->arm_r1, err);
1067 __put_user_error(env->regs[2], &sc->arm_r2, err);
1068 __put_user_error(env->regs[3], &sc->arm_r3, err);
1069 __put_user_error(env->regs[4], &sc->arm_r4, err);
1070 __put_user_error(env->regs[5], &sc->arm_r5, err);
1071 __put_user_error(env->regs[6], &sc->arm_r6, err);
1072 __put_user_error(env->regs[7], &sc->arm_r7, err);
1073 __put_user_error(env->regs[8], &sc->arm_r8, err);
1074 __put_user_error(env->regs[9], &sc->arm_r9, err);
1075 __put_user_error(env->regs[10], &sc->arm_r10, err);
1076 __put_user_error(env->regs[11], &sc->arm_fp, err);
1077 __put_user_error(env->regs[12], &sc->arm_ip, err);
1078 __put_user_error(env->regs[13], &sc->arm_sp, err);
1079 __put_user_error(env->regs[14], &sc->arm_lr, err);
1080 __put_user_error(env->regs[15], &sc->arm_pc, err);
1081 #ifdef TARGET_CONFIG_CPU_32
1082 __put_user_error(cpsr_read(env), &sc->arm_cpsr, err);
1083 #endif
1084
1085 __put_user_error(/* current->thread.trap_no */ 0, &sc->trap_no, err);
1086 __put_user_error(/* current->thread.error_code */ 0, &sc->error_code, err);
1087 __put_user_error(/* current->thread.address */ 0, &sc->fault_address, err);
1088 __put_user_error(mask, &sc->oldmask, err);
1089
1090 return err;
1091 }
1092
1093 static inline void *
1094 get_sigframe(struct emulated_sigaction *ka, CPUState *regs, int framesize)
1095 {
1096 unsigned long sp = regs->regs[13];
1097
1098 /*
1099 * This is the X/Open sanctioned signal stack switching.
1100 */
1101 if ((ka->sa.sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp))
1102 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1103 /*
1104 * ATPCS B01 mandates 8-byte alignment
1105 */
1106 return g2h((sp - framesize) & ~7);
1107 }
1108
1109 static int
1110 setup_return(CPUState *env, struct emulated_sigaction *ka,
1111 abi_ulong *rc, void *frame, int usig)
1112 {
1113 abi_ulong handler = (abi_ulong)ka->sa._sa_handler;
1114 abi_ulong retcode;
1115 int thumb = 0;
1116 #if defined(TARGET_CONFIG_CPU_32)
1117 #if 0
1118 abi_ulong cpsr = env->cpsr;
1119
1120 /*
1121 * Maybe we need to deliver a 32-bit signal to a 26-bit task.
1122 */
1123 if (ka->sa.sa_flags & SA_THIRTYTWO)
1124 cpsr = (cpsr & ~MODE_MASK) | USR_MODE;
1125
1126 #ifdef CONFIG_ARM_THUMB
1127 if (elf_hwcap & HWCAP_THUMB) {
1128 /*
1129 * The LSB of the handler determines if we're going to
1130 * be using THUMB or ARM mode for this signal handler.
1131 */
1132 thumb = handler & 1;
1133
1134 if (thumb)
1135 cpsr |= T_BIT;
1136 else
1137 cpsr &= ~T_BIT;
1138 }
1139 #endif /* CONFIG_ARM_THUMB */
1140 #endif /* 0 */
1141 #endif /* TARGET_CONFIG_CPU_32 */
1142
1143 if (ka->sa.sa_flags & TARGET_SA_RESTORER) {
1144 retcode = (abi_ulong)ka->sa.sa_restorer;
1145 } else {
1146 unsigned int idx = thumb;
1147
1148 if (ka->sa.sa_flags & TARGET_SA_SIGINFO)
1149 idx += 2;
1150
1151 if (__put_user(retcodes[idx], rc))
1152 return 1;
1153 #if 0
1154 flush_icache_range((abi_ulong)rc,
1155 (abi_ulong)(rc + 1));
1156 #endif
1157 retcode = ((abi_ulong)rc) + thumb;
1158 }
1159
1160 env->regs[0] = usig;
1161 env->regs[13] = h2g(frame);
1162 env->regs[14] = retcode;
1163 env->regs[15] = handler & (thumb ? ~1 : ~3);
1164
1165 #if 0
1166 #ifdef TARGET_CONFIG_CPU_32
1167 env->cpsr = cpsr;
1168 #endif
1169 #endif
1170
1171 return 0;
1172 }
1173
1174 static void setup_frame(int usig, struct emulated_sigaction *ka,
1175 target_sigset_t *set, CPUState *regs)
1176 {
1177 struct sigframe *frame = get_sigframe(ka, regs, sizeof(*frame));
1178 int i, err = 0;
1179
1180 err |= setup_sigcontext(&frame->sc, /*&frame->fpstate,*/ regs, set->sig[0]);
1181
1182 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1183 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
1184 return;
1185 }
1186
1187 if (err == 0)
1188 err = setup_return(regs, ka, &frame->retcode, frame, usig);
1189 // return err;
1190 }
1191
1192 static void setup_rt_frame(int usig, struct emulated_sigaction *ka,
1193 target_siginfo_t *info,
1194 target_sigset_t *set, CPUState *env)
1195 {
1196 struct rt_sigframe *frame = get_sigframe(ka, env, sizeof(*frame));
1197 struct target_sigaltstack stack;
1198 int i, err = 0;
1199
1200 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
1201 return /* 1 */;
1202
1203 __put_user_error(&frame->info, (abi_ulong *)&frame->pinfo, err);
1204 __put_user_error(&frame->uc, (abi_ulong *)&frame->puc, err);
1205 err |= copy_siginfo_to_user(&frame->info, info);
1206
1207 /* Clear all the bits of the ucontext we don't use. */
1208 memset(&frame->uc, 0, offsetof(struct target_ucontext, tuc_mcontext));
1209
1210 memset(&stack, 0, sizeof(stack));
1211 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1212 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1213 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
1214 if (!access_ok(VERIFY_WRITE, &frame->uc.tuc_stack, sizeof(stack)))
1215 err = 1;
1216 else
1217 memcpy(&frame->uc.tuc_stack, &stack, sizeof(stack));
1218
1219 err |= setup_sigcontext(&frame->uc.tuc_mcontext, /*&frame->fpstate,*/
1220 env, set->sig[0]);
1221 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1222 if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
1223 return;
1224 }
1225
1226 if (err == 0)
1227 err = setup_return(env, ka, &frame->retcode, frame, usig);
1228
1229 if (err == 0) {
1230 /*
1231 * For realtime signals we must also set the second and third
1232 * arguments for the signal handler.
1233 * -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06
1234 */
1235 env->regs[1] = (abi_ulong)frame->pinfo;
1236 env->regs[2] = (abi_ulong)frame->puc;
1237 }
1238
1239 // return err;
1240 }
1241
1242 static int
1243 restore_sigcontext(CPUState *env, struct target_sigcontext *sc)
1244 {
1245 int err = 0;
1246 uint32_t cpsr;
1247
1248 __get_user_error(env->regs[0], &sc->arm_r0, err);
1249 __get_user_error(env->regs[1], &sc->arm_r1, err);
1250 __get_user_error(env->regs[2], &sc->arm_r2, err);
1251 __get_user_error(env->regs[3], &sc->arm_r3, err);
1252 __get_user_error(env->regs[4], &sc->arm_r4, err);
1253 __get_user_error(env->regs[5], &sc->arm_r5, err);
1254 __get_user_error(env->regs[6], &sc->arm_r6, err);
1255 __get_user_error(env->regs[7], &sc->arm_r7, err);
1256 __get_user_error(env->regs[8], &sc->arm_r8, err);
1257 __get_user_error(env->regs[9], &sc->arm_r9, err);
1258 __get_user_error(env->regs[10], &sc->arm_r10, err);
1259 __get_user_error(env->regs[11], &sc->arm_fp, err);
1260 __get_user_error(env->regs[12], &sc->arm_ip, err);
1261 __get_user_error(env->regs[13], &sc->arm_sp, err);
1262 __get_user_error(env->regs[14], &sc->arm_lr, err);
1263 __get_user_error(env->regs[15], &sc->arm_pc, err);
1264 #ifdef TARGET_CONFIG_CPU_32
1265 __get_user_error(cpsr, &sc->arm_cpsr, err);
1266 cpsr_write(env, cpsr, 0xffffffff);
1267 #endif
1268
1269 err |= !valid_user_regs(env);
1270
1271 return err;
1272 }
1273
1274 long do_sigreturn(CPUState *env)
1275 {
1276 struct sigframe *frame;
1277 target_sigset_t set;
1278 sigset_t host_set;
1279 int i;
1280
1281 /*
1282 * Since we stacked the signal on a 64-bit boundary,
1283 * then 'sp' should be word aligned here. If it's
1284 * not, then the user is trying to mess with us.
1285 */
1286 if (env->regs[13] & 7)
1287 goto badframe;
1288
1289 frame = (struct sigframe *)g2h(env->regs[13]);
1290
1291 #if 0
1292 if (verify_area(VERIFY_READ, frame, sizeof (*frame)))
1293 goto badframe;
1294 #endif
1295 if (__get_user(set.sig[0], &frame->sc.oldmask))
1296 goto badframe;
1297 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1298 if (__get_user(set.sig[i], &frame->extramask[i - 1]))
1299 goto badframe;
1300 }
1301
1302 target_to_host_sigset_internal(&host_set, &set);
1303 sigprocmask(SIG_SETMASK, &host_set, NULL);
1304
1305 if (restore_sigcontext(env, &frame->sc))
1306 goto badframe;
1307
1308 #if 0
1309 /* Send SIGTRAP if we're single-stepping */
1310 if (ptrace_cancel_bpt(current))
1311 send_sig(SIGTRAP, current, 1);
1312 #endif
1313 return env->regs[0];
1314
1315 badframe:
1316 force_sig(SIGSEGV /* , current */);
1317 return 0;
1318 }
1319
1320 long do_rt_sigreturn(CPUState *env)
1321 {
1322 struct rt_sigframe *frame;
1323 sigset_t host_set;
1324
1325 /*
1326 * Since we stacked the signal on a 64-bit boundary,
1327 * then 'sp' should be word aligned here. If it's
1328 * not, then the user is trying to mess with us.
1329 */
1330 if (env->regs[13] & 7)
1331 goto badframe;
1332
1333 frame = (struct rt_sigframe *)env->regs[13];
1334
1335 #if 0
1336 if (verify_area(VERIFY_READ, frame, sizeof (*frame)))
1337 goto badframe;
1338 #endif
1339 target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask);
1340 sigprocmask(SIG_SETMASK, &host_set, NULL);
1341
1342 if (restore_sigcontext(env, &frame->uc.tuc_mcontext))
1343 goto badframe;
1344
1345 if (do_sigaltstack(&frame->uc.tuc_stack, NULL, get_sp_from_cpustate(env)) == -EFAULT)
1346 goto badframe;
1347
1348 #if 0
1349 /* Send SIGTRAP if we're single-stepping */
1350 if (ptrace_cancel_bpt(current))
1351 send_sig(SIGTRAP, current, 1);
1352 #endif
1353 return env->regs[0];
1354
1355 badframe:
1356 force_sig(SIGSEGV /* , current */);
1357 return 0;
1358 }
1359
1360 #elif defined(TARGET_SPARC)
1361
1362 #define __SUNOS_MAXWIN 31
1363
1364 /* This is what SunOS does, so shall I. */
1365 struct target_sigcontext {
1366 abi_ulong sigc_onstack; /* state to restore */
1367
1368 abi_ulong sigc_mask; /* sigmask to restore */
1369 abi_ulong sigc_sp; /* stack pointer */
1370 abi_ulong sigc_pc; /* program counter */
1371 abi_ulong sigc_npc; /* next program counter */
1372 abi_ulong sigc_psr; /* for condition codes etc */
1373 abi_ulong sigc_g1; /* User uses these two registers */
1374 abi_ulong sigc_o0; /* within the trampoline code. */
1375
1376 /* Now comes information regarding the users window set
1377 * at the time of the signal.
1378 */
1379 abi_ulong sigc_oswins; /* outstanding windows */
1380
1381 /* stack ptrs for each regwin buf */
1382 char *sigc_spbuf[__SUNOS_MAXWIN];
1383
1384 /* Windows to restore after signal */
1385 struct {
1386 abi_ulong locals[8];
1387 abi_ulong ins[8];
1388 } sigc_wbuf[__SUNOS_MAXWIN];
1389 };
1390 /* A Sparc stack frame */
1391 struct sparc_stackf {
1392 abi_ulong locals[8];
1393 abi_ulong ins[6];
1394 struct sparc_stackf *fp;
1395 abi_ulong callers_pc;
1396 char *structptr;
1397 abi_ulong xargs[6];
1398 abi_ulong xxargs[1];
1399 };
1400
1401 typedef struct {
1402 struct {
1403 abi_ulong psr;
1404 abi_ulong pc;
1405 abi_ulong npc;
1406 abi_ulong y;
1407 abi_ulong u_regs[16]; /* globals and ins */
1408 } si_regs;
1409 int si_mask;
1410 } __siginfo_t;
1411
1412 typedef struct {
1413 unsigned long si_float_regs [32];
1414 unsigned long si_fsr;
1415 unsigned long si_fpqdepth;
1416 struct {
1417 unsigned long *insn_addr;
1418 unsigned long insn;
1419 } si_fpqueue [16];
1420 } qemu_siginfo_fpu_t;
1421
1422
1423 struct target_signal_frame {
1424 struct sparc_stackf ss;
1425 __siginfo_t info;
1426 qemu_siginfo_fpu_t *fpu_save;
1427 abi_ulong insns[2] __attribute__ ((aligned (8)));
1428 abi_ulong extramask[TARGET_NSIG_WORDS - 1];
1429 abi_ulong extra_size; /* Should be 0 */
1430 qemu_siginfo_fpu_t fpu_state;
1431 };
1432 struct target_rt_signal_frame {
1433 struct sparc_stackf ss;
1434 siginfo_t info;
1435 abi_ulong regs[20];
1436 sigset_t mask;
1437 qemu_siginfo_fpu_t *fpu_save;
1438 unsigned int insns[2];
1439 stack_t stack;
1440 unsigned int extra_size; /* Should be 0 */
1441 qemu_siginfo_fpu_t fpu_state;
1442 };
1443
1444 #define UREG_O0 16
1445 #define UREG_O6 22
1446 #define UREG_I0 0
1447 #define UREG_I1 1
1448 #define UREG_I2 2
1449 #define UREG_I3 3
1450 #define UREG_I4 4
1451 #define UREG_I5 5
1452 #define UREG_I6 6
1453 #define UREG_I7 7
1454 #define UREG_L0 8
1455 #define UREG_FP UREG_I6
1456 #define UREG_SP UREG_O6
1457
1458 static inline void *get_sigframe(struct emulated_sigaction *sa, CPUState *env, unsigned long framesize)
1459 {
1460 unsigned long sp;
1461
1462 sp = env->regwptr[UREG_FP];
1463
1464 /* This is the X/Open sanctioned signal stack switching. */
1465 if (sa->sa.sa_flags & TARGET_SA_ONSTACK) {
1466 if (!on_sig_stack(sp)
1467 && !((target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size) & 7))
1468 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1469 }
1470 return g2h(sp - framesize);
1471 }
1472
1473 static int
1474 setup___siginfo(__siginfo_t *si, CPUState *env, abi_ulong mask)
1475 {
1476 int err = 0, i;
1477
1478 err |= __put_user(env->psr, &si->si_regs.psr);
1479 err |= __put_user(env->pc, &si->si_regs.pc);
1480 err |= __put_user(env->npc, &si->si_regs.npc);
1481 err |= __put_user(env->y, &si->si_regs.y);
1482 for (i=0; i < 8; i++) {
1483 err |= __put_user(env->gregs[i], &si->si_regs.u_regs[i]);
1484 }
1485 for (i=0; i < 8; i++) {
1486 err |= __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]);
1487 }
1488 err |= __put_user(mask, &si->si_mask);
1489 return err;
1490 }
1491
1492 #if 0
1493 static int
1494 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1495 CPUState *env, unsigned long mask)
1496 {
1497 int err = 0;
1498
1499 err |= __put_user(mask, &sc->sigc_mask);
1500 err |= __put_user(env->regwptr[UREG_SP], &sc->sigc_sp);
1501 err |= __put_user(env->pc, &sc->sigc_pc);
1502 err |= __put_user(env->npc, &sc->sigc_npc);
1503 err |= __put_user(env->psr, &sc->sigc_psr);
1504 err |= __put_user(env->gregs[1], &sc->sigc_g1);
1505 err |= __put_user(env->regwptr[UREG_O0], &sc->sigc_o0);
1506
1507 return err;
1508 }
1509 #endif
1510 #define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7)))
1511
1512 static void setup_frame(int sig, struct emulated_sigaction *ka,
1513 target_sigset_t *set, CPUState *env)
1514 {
1515 struct target_signal_frame *sf;
1516 int sigframe_size, err, i;
1517
1518 /* 1. Make sure everything is clean */
1519 //synchronize_user_stack();
1520
1521 sigframe_size = NF_ALIGNEDSZ;
1522
1523 sf = (struct target_signal_frame *)
1524 get_sigframe(ka, env, sigframe_size);
1525
1526 //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1527 #if 0
1528 if (invalid_frame_pointer(sf, sigframe_size))
1529 goto sigill_and_return;
1530 #endif
1531 /* 2. Save the current process state */
1532 err = setup___siginfo(&sf->info, env, set->sig[0]);
1533 err |= __put_user(0, &sf->extra_size);
1534
1535 //err |= save_fpu_state(regs, &sf->fpu_state);
1536 //err |= __put_user(&sf->fpu_state, &sf->fpu_save);
1537
1538 err |= __put_user(set->sig[0], &sf->info.si_mask);
1539 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
1540 err |= __put_user(set->sig[i + 1], &sf->extramask[i]);
1541 }
1542
1543 for (i = 0; i < 8; i++) {
1544 err |= __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]);
1545 }
1546 for (i = 0; i < 8; i++) {
1547 err |= __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]);
1548 }
1549 if (err)
1550 goto sigsegv;
1551
1552 /* 3. signal handler back-trampoline and parameters */
1553 env->regwptr[UREG_FP] = h2g(sf);
1554 env->regwptr[UREG_I0] = sig;
1555 env->regwptr[UREG_I1] = h2g(&sf->info);
1556 env->regwptr[UREG_I2] = h2g(&sf->info);
1557
1558 /* 4. signal handler */
1559 env->pc = (unsigned long) ka->sa._sa_handler;
1560 env->npc = (env->pc + 4);
1561 /* 5. return to kernel instructions */
1562 if (ka->sa.sa_restorer)
1563 env->regwptr[UREG_I7] = (unsigned long)ka->sa.sa_restorer;
1564 else {
1565 env->regwptr[UREG_I7] = h2g(&(sf->insns[0]) - 2);
1566
1567 /* mov __NR_sigreturn, %g1 */
1568 err |= __put_user(0x821020d8, &sf->insns[0]);
1569
1570 /* t 0x10 */
1571 err |= __put_user(0x91d02010, &sf->insns[1]);
1572 if (err)
1573 goto sigsegv;
1574
1575 /* Flush instruction space. */
1576 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
1577 // tb_flush(env);
1578 }
1579 return;
1580
1581 //sigill_and_return:
1582 force_sig(TARGET_SIGILL);
1583 sigsegv:
1584 //fprintf(stderr, "force_sig\n");
1585 force_sig(TARGET_SIGSEGV);
1586 }
1587 static inline int
1588 restore_fpu_state(CPUState *env, qemu_siginfo_fpu_t *fpu)
1589 {
1590 int err;
1591 #if 0
1592 #ifdef CONFIG_SMP
1593 if (current->flags & PF_USEDFPU)
1594 regs->psr &= ~PSR_EF;
1595 #else
1596 if (current == last_task_used_math) {
1597 last_task_used_math = 0;
1598 regs->psr &= ~PSR_EF;
1599 }
1600 #endif
1601 current->used_math = 1;
1602 current->flags &= ~PF_USEDFPU;
1603 #endif
1604 #if 0
1605 if (verify_area (VERIFY_READ, fpu, sizeof(*fpu)))
1606 return -EFAULT;
1607 #endif
1608
1609 #if 0
1610 /* XXX: incorrect */
1611 err = __copy_from_user(&env->fpr[0], &fpu->si_float_regs[0],
1612 (sizeof(unsigned long) * 32));
1613 #endif
1614 err |= __get_user(env->fsr, &fpu->si_fsr);
1615 #if 0
1616 err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
1617 if (current->thread.fpqdepth != 0)
1618 err |= __copy_from_user(&current->thread.fpqueue[0],
1619 &fpu->si_fpqueue[0],
1620 ((sizeof(unsigned long) +
1621 (sizeof(unsigned long *)))*16));
1622 #endif
1623 return err;
1624 }
1625
1626
1627 static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
1628 target_siginfo_t *info,
1629 target_sigset_t *set, CPUState *env)
1630 {
1631 fprintf(stderr, "setup_rt_frame: not implemented\n");
1632 }
1633
1634 long do_sigreturn(CPUState *env)
1635 {
1636 struct target_signal_frame *sf;
1637 uint32_t up_psr, pc, npc;
1638 target_sigset_t set;
1639 sigset_t host_set;
1640 abi_ulong fpu_save;
1641 int err, i;
1642
1643 sf = (struct target_signal_frame *)g2h(env->regwptr[UREG_FP]);
1644 #if 0
1645 fprintf(stderr, "sigreturn\n");
1646 fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1647 #endif
1648 //cpu_dump_state(env, stderr, fprintf, 0);
1649
1650 /* 1. Make sure we are not getting garbage from the user */
1651 #if 0
1652 if (verify_area (VERIFY_READ, sf, sizeof (*sf)))
1653 goto segv_and_exit;
1654 #endif
1655
1656 if (((uint) sf) & 3)
1657 goto segv_and_exit;
1658
1659 err = __get_user(pc, &sf->info.si_regs.pc);
1660 err |= __get_user(npc, &sf->info.si_regs.npc);
1661
1662 if ((pc | npc) & 3)
1663 goto segv_and_exit;
1664
1665 /* 2. Restore the state */
1666 err |= __get_user(up_psr, &sf->info.si_regs.psr);
1667
1668 /* User can only change condition codes and FPU enabling in %psr. */
1669 env->psr = (up_psr & (PSR_ICC /* | PSR_EF */))
1670 | (env->psr & ~(PSR_ICC /* | PSR_EF */));
1671
1672 env->pc = pc;
1673 env->npc = npc;
1674 err |= __get_user(env->y, &sf->info.si_regs.y);
1675 for (i=0; i < 8; i++) {
1676 err |= __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]);
1677 }
1678 for (i=0; i < 8; i++) {
1679 err |= __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]);
1680 }
1681
1682 err |= __get_user(fpu_save, (abi_ulong *)&sf->fpu_save);
1683
1684 //if (fpu_save)
1685 // err |= restore_fpu_state(env, fpu_save);
1686
1687 /* This is pretty much atomic, no amount locking would prevent
1688 * the races which exist anyways.
1689 */
1690 err |= __get_user(set.sig[0], &sf->info.si_mask);
1691 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1692 err |= (__get_user(set.sig[i], &sf->extramask[i - 1]));
1693 }
1694
1695 target_to_host_sigset_internal(&host_set, &set);
1696 sigprocmask(SIG_SETMASK, &host_set, NULL);
1697
1698 if (err)
1699 goto segv_and_exit;
1700
1701 return env->regwptr[0];
1702
1703 segv_and_exit:
1704 force_sig(TARGET_SIGSEGV);
1705 }
1706
1707 long do_rt_sigreturn(CPUState *env)
1708 {
1709 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
1710 return -ENOSYS;
1711 }
1712
1713 #ifdef TARGET_SPARC64
1714 #define MC_TSTATE 0
1715 #define MC_PC 1
1716 #define MC_NPC 2
1717 #define MC_Y 3
1718 #define MC_G1 4
1719 #define MC_G2 5
1720 #define MC_G3 6
1721 #define MC_G4 7
1722 #define MC_G5 8
1723 #define MC_G6 9
1724 #define MC_G7 10
1725 #define MC_O0 11
1726 #define MC_O1 12
1727 #define MC_O2 13
1728 #define MC_O3 14
1729 #define MC_O4 15
1730 #define MC_O5 16
1731 #define MC_O6 17
1732 #define MC_O7 18
1733 #define MC_NGREG 19
1734
1735 typedef abi_ulong target_mc_greg_t;
1736 typedef target_mc_greg_t target_mc_gregset_t[MC_NGREG];
1737
1738 struct target_mc_fq {
1739 abi_ulong *mcfq_addr;
1740 uint32_t mcfq_insn;
1741 };
1742
1743 struct target_mc_fpu {
1744 union {
1745 uint32_t sregs[32];
1746 uint64_t dregs[32];
1747 //uint128_t qregs[16];
1748 } mcfpu_fregs;
1749 abi_ulong mcfpu_fsr;
1750 abi_ulong mcfpu_fprs;
1751 abi_ulong mcfpu_gsr;
1752 struct target_mc_fq *mcfpu_fq;
1753 unsigned char mcfpu_qcnt;
1754 unsigned char mcfpu_qentsz;
1755 unsigned char mcfpu_enab;
1756 };
1757 typedef struct target_mc_fpu target_mc_fpu_t;
1758
1759 typedef struct {
1760 target_mc_gregset_t mc_gregs;
1761 target_mc_greg_t mc_fp;
1762 target_mc_greg_t mc_i7;
1763 target_mc_fpu_t mc_fpregs;
1764 } target_mcontext_t;
1765
1766 struct target_ucontext {
1767 struct target_ucontext *uc_link;
1768 abi_ulong uc_flags;
1769 target_sigset_t uc_sigmask;
1770 target_mcontext_t uc_mcontext;
1771 };
1772
1773 /* A V9 register window */
1774 struct target_reg_window {
1775 abi_ulong locals[8];
1776 abi_ulong ins[8];
1777 };
1778
1779 #define TARGET_STACK_BIAS 2047
1780
1781 /* {set, get}context() needed for 64-bit SparcLinux userland. */
1782 void sparc64_set_context(CPUSPARCState *env)
1783 {
1784 struct target_ucontext *ucp = (struct target_ucontext *)
1785 env->regwptr[UREG_I0];
1786 target_mc_gregset_t *grp;
1787 abi_ulong pc, npc, tstate;
1788 abi_ulong fp, i7;
1789 unsigned char fenab;
1790 int err;
1791 unsigned int i;
1792 abi_ulong *src, *dst;
1793
1794 grp = &ucp->uc_mcontext.mc_gregs;
1795 err = get_user(pc, &((*grp)[MC_PC]));
1796 err |= get_user(npc, &((*grp)[MC_NPC]));
1797 if (err || ((pc | npc) & 3))
1798 goto do_sigsegv;
1799 if (env->regwptr[UREG_I1]) {
1800 target_sigset_t target_set;
1801 sigset_t set;
1802
1803 if (TARGET_NSIG_WORDS == 1) {
1804 if (get_user(target_set.sig[0], &ucp->uc_sigmask.sig[0]))
1805 goto do_sigsegv;
1806 } else {
1807 src = &ucp->uc_sigmask;
1808 dst = &target_set;
1809 for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong);
1810 i++, dst++, src++)
1811 err |= get_user(dst, src);
1812 if (err)
1813 goto do_sigsegv;
1814 }
1815 target_to_host_sigset_internal(&set, &target_set);
1816 sigprocmask(SIG_SETMASK, &set, NULL);
1817 }
1818 env->pc = pc;
1819 env->npc = npc;
1820 err |= get_user(env->y, &((*grp)[MC_Y]));
1821 err |= get_user(tstate, &((*grp)[MC_TSTATE]));
1822 env->asi = (tstate >> 24) & 0xff;
1823 PUT_CCR(env, tstate >> 32);
1824 PUT_CWP64(env, tstate & 0x1f);
1825 err |= get_user(env->gregs[1], (&(*grp)[MC_G1]));
1826 err |= get_user(env->gregs[2], (&(*grp)[MC_G2]));
1827 err |= get_user(env->gregs[3], (&(*grp)[MC_G3]));
1828 err |= get_user(env->gregs[4], (&(*grp)[MC_G4]));
1829 err |= get_user(env->gregs[5], (&(*grp)[MC_G5]));
1830 err |= get_user(env->gregs[6], (&(*grp)[MC_G6]));
1831 err |= get_user(env->gregs[7], (&(*grp)[MC_G7]));
1832 err |= get_user(env->regwptr[UREG_I0], (&(*grp)[MC_O0]));
1833 err |= get_user(env->regwptr[UREG_I1], (&(*grp)[MC_O1]));
1834 err |= get_user(env->regwptr[UREG_I2], (&(*grp)[MC_O2]));
1835 err |= get_user(env->regwptr[UREG_I3], (&(*grp)[MC_O3]));
1836 err |= get_user(env->regwptr[UREG_I4], (&(*grp)[MC_O4]));
1837 err |= get_user(env->regwptr[UREG_I5], (&(*grp)[MC_O5]));
1838 err |= get_user(env->regwptr[UREG_I6], (&(*grp)[MC_O6]));
1839 err |= get_user(env->regwptr[UREG_I7], (&(*grp)[MC_O7]));
1840
1841 err |= get_user(fp, &(ucp->uc_mcontext.mc_fp));
1842 err |= get_user(i7, &(ucp->uc_mcontext.mc_i7));
1843 err |= put_user(fp,
1844 (&(((struct target_reg_window *)(TARGET_STACK_BIAS+env->regwptr[UREG_I6]))->ins[6])));
1845 err |= put_user(i7,
1846 (&(((struct target_reg_window *)(TARGET_STACK_BIAS+env->regwptr[UREG_I6]))->ins[7])));
1847
1848 err |= get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab));
1849 err |= get_user(env->fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs));
1850 src = &(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs);
1851 dst = &env->fpr;
1852 for (i = 0; i < 64; i++, dst++, src++)
1853 err |= get_user(dst, src);
1854 err |= get_user(env->fsr,
1855 &(ucp->uc_mcontext.mc_fpregs.mcfpu_fsr));
1856 err |= get_user(env->gsr,
1857 &(ucp->uc_mcontext.mc_fpregs.mcfpu_gsr));
1858 if (err)
1859 goto do_sigsegv;
1860
1861 return;
1862 do_sigsegv:
1863 force_sig(SIGSEGV);
1864 }
1865
1866 void sparc64_get_context(CPUSPARCState *env)
1867 {
1868 struct target_ucontext *ucp = (struct target_ucontext *)
1869 env->regwptr[UREG_I0];
1870 target_mc_gregset_t *grp;
1871 target_mcontext_t *mcp;
1872 abi_ulong fp, i7;
1873 int err;
1874 unsigned int i;
1875 abi_ulong *src, *dst;
1876 target_sigset_t target_set;
1877 sigset_t set;
1878
1879 mcp = &ucp->uc_mcontext;
1880 grp = &mcp->mc_gregs;
1881
1882 /* Skip over the trap instruction, first. */
1883 env->pc = env->npc;
1884 env->npc += 4;
1885
1886 err = 0;
1887
1888 sigprocmask(0, NULL, &set);
1889 host_to_target_sigset_internal(&target_set, &set);
1890 if (TARGET_NSIG_WORDS == 1)
1891 err |= put_user(target_set.sig[0],
1892 (abi_ulong *)&ucp->uc_sigmask);
1893 else {
1894 src = &target_set;
1895 dst = &ucp->uc_sigmask;
1896 for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong);
1897 i++, dst++, src++)
1898 err |= put_user(src, dst);
1899 if (err)
1900 goto do_sigsegv;
1901 }
1902
1903 err |= put_user(env->tstate, &((*grp)[MC_TSTATE]));
1904 err |= put_user(env->pc, &((*grp)[MC_PC]));
1905 err |= put_user(env->npc, &((*grp)[MC_NPC]));
1906 err |= put_user(env->y, &((*grp)[MC_Y]));
1907 err |= put_user(env->gregs[1], &((*grp)[MC_G1]));
1908 err |= put_user(env->gregs[2], &((*grp)[MC_G2]));
1909 err |= put_user(env->gregs[3], &((*grp)[MC_G3]));
1910 err |= put_user(env->gregs[4], &((*grp)[MC_G4]));
1911 err |= put_user(env->gregs[5], &((*grp)[MC_G5]));
1912 err |= put_user(env->gregs[6], &((*grp)[MC_G6]));
1913 err |= put_user(env->gregs[7], &((*grp)[MC_G7]));
1914 err |= put_user(env->regwptr[UREG_I0], &((*grp)[MC_O0]));
1915 err |= put_user(env->regwptr[UREG_I1], &((*grp)[MC_O1]));
1916 err |= put_user(env->regwptr[UREG_I2], &((*grp)[MC_O2]));
1917 err |= put_user(env->regwptr[UREG_I3], &((*grp)[MC_O3]));
1918 err |= put_user(env->regwptr[UREG_I4], &((*grp)[MC_O4]));
1919 err |= put_user(env->regwptr[UREG_I5], &((*grp)[MC_O5]));
1920 err |= put_user(env->regwptr[UREG_I6], &((*grp)[MC_O6]));
1921 err |= put_user(env->regwptr[UREG_I7], &((*grp)[MC_O7]));
1922
1923 err |= get_user(fp,
1924 (&(((struct target_reg_window *)(TARGET_STACK_BIAS+env->regwptr[UREG_I6]))->ins[6])));
1925 err |= get_user(i7,
1926 (&(((struct target_reg_window *)(TARGET_STACK_BIAS+env->regwptr[UREG_I6]))->ins[7])));
1927 err |= put_user(fp, &(mcp->mc_fp));
1928 err |= put_user(i7, &(mcp->mc_i7));
1929
1930 src = &env->fpr;
1931 dst = &(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs);
1932 for (i = 0; i < 64; i++, dst++, src++)
1933 err |= put_user(src, dst);
1934 err |= put_user(env->fsr, &(mcp->mc_fpregs.mcfpu_fsr));
1935 err |= put_user(env->gsr, &(mcp->mc_fpregs.mcfpu_gsr));
1936 err |= put_user(env->fprs, &(mcp->mc_fpregs.mcfpu_fprs));
1937
1938 if (err)
1939 goto do_sigsegv;
1940
1941 return;
1942 do_sigsegv:
1943 force_sig(SIGSEGV);
1944 }
1945 #endif
1946 #elif defined(TARGET_MIPS64)
1947
1948 # warning signal handling not implemented
1949
1950 static void setup_frame(int sig, struct emulated_sigaction *ka,
1951 target_sigset_t *set, CPUState *env)
1952 {
1953 fprintf(stderr, "setup_frame: not implemented\n");
1954 }
1955
1956 static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
1957 target_siginfo_t *info,
1958 target_sigset_t *set, CPUState *env)
1959 {
1960 fprintf(stderr, "setup_rt_frame: not implemented\n");
1961 }
1962
1963 long do_sigreturn(CPUState *env)
1964 {
1965 fprintf(stderr, "do_sigreturn: not implemented\n");
1966 return -ENOSYS;
1967 }
1968
1969 long do_rt_sigreturn(CPUState *env)
1970 {
1971 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
1972 return -ENOSYS;
1973 }
1974
1975 #elif defined(TARGET_MIPSN32)
1976
1977 # warning signal handling not implemented
1978
1979 static void setup_frame(int sig, struct emulated_sigaction *ka,
1980 target_sigset_t *set, CPUState *env)
1981 {
1982 fprintf(stderr, "setup_frame: not implemented\n");
1983 }
1984
1985 static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
1986 target_siginfo_t *info,
1987 target_sigset_t *set, CPUState *env)
1988 {
1989 fprintf(stderr, "setup_rt_frame: not implemented\n");
1990 }
1991
1992 long do_sigreturn(CPUState *env)
1993 {
1994 fprintf(stderr, "do_sigreturn: not implemented\n");
1995 return -ENOSYS;
1996 }
1997
1998 long do_rt_sigreturn(CPUState *env)
1999 {
2000 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
2001 return -ENOSYS;
2002 }
2003
2004 #elif defined(TARGET_MIPS)
2005
2006 struct target_sigcontext {
2007 uint32_t sc_regmask; /* Unused */
2008 uint32_t sc_status;
2009 uint64_t sc_pc;
2010 uint64_t sc_regs[32];
2011 uint64_t sc_fpregs[32];
2012 uint32_t sc_ownedfp; /* Unused */
2013 uint32_t sc_fpc_csr;
2014 uint32_t sc_fpc_eir; /* Unused */
2015 uint32_t sc_used_math;
2016 uint32_t sc_dsp; /* dsp status, was sc_ssflags */
2017 uint64_t sc_mdhi;
2018 uint64_t sc_mdlo;
2019 target_ulong sc_hi1; /* Was sc_cause */
2020 target_ulong sc_lo1; /* Was sc_badvaddr */
2021 target_ulong sc_hi2; /* Was sc_sigset[4] */
2022 target_ulong sc_lo2;
2023 target_ulong sc_hi3;
2024 target_ulong sc_lo3;
2025 };
2026
2027 struct sigframe {
2028 uint32_t sf_ass[4]; /* argument save space for o32 */
2029 uint32_t sf_code[2]; /* signal trampoline */
2030 struct target_sigcontext sf_sc;
2031 target_sigset_t sf_mask;
2032 };
2033
2034 /* Install trampoline to jump back from signal handler */
2035 static inline int install_sigtramp(unsigned int *tramp, unsigned int syscall)
2036 {
2037 int err;
2038
2039 /*
2040 * Set up the return code ...
2041 *
2042 * li v0, __NR__foo_sigreturn
2043 * syscall
2044 */
2045
2046 err = __put_user(0x24020000 + syscall, tramp + 0);
2047 err |= __put_user(0x0000000c , tramp + 1);
2048 /* flush_cache_sigtramp((unsigned long) tramp); */
2049 return err;
2050 }
2051
2052 static inline int
2053 setup_sigcontext(CPUState *regs, struct target_sigcontext *sc)
2054 {
2055 int err = 0;
2056
2057 err |= __put_user(regs->PC[regs->current_tc], &sc->sc_pc);
2058
2059 #define save_gp_reg(i) do { \
2060 err |= __put_user(regs->gpr[i][regs->current_tc], &sc->sc_regs[i]); \
2061 } while(0)
2062 __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
2063 save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
2064 save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
2065 save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
2066 save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
2067 save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
2068 save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
2069 save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
2070 save_gp_reg(31);
2071 #undef save_gp_reg
2072
2073 err |= __put_user(regs->HI[0][regs->current_tc], &sc->sc_mdhi);
2074 err |= __put_user(regs->LO[0][regs->current_tc], &sc->sc_mdlo);
2075
2076 /* Not used yet, but might be useful if we ever have DSP suppport */
2077 #if 0
2078 if (cpu_has_dsp) {
2079 err |= __put_user(mfhi1(), &sc->sc_hi1);
2080 err |= __put_user(mflo1(), &sc->sc_lo1);
2081 err |= __put_user(mfhi2(), &sc->sc_hi2);
2082 err |= __put_user(mflo2(), &sc->sc_lo2);
2083 err |= __put_user(mfhi3(), &sc->sc_hi3);
2084 err |= __put_user(mflo3(), &sc->sc_lo3);
2085 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
2086 }
2087 /* same with 64 bit */
2088 #ifdef CONFIG_64BIT
2089 err |= __put_user(regs->hi, &sc->sc_hi[0]);
2090 err |= __put_user(regs->lo, &sc->sc_lo[0]);
2091 if (cpu_has_dsp) {
2092 err |= __put_user(mfhi1(), &sc->sc_hi[1]);
2093 err |= __put_user(mflo1(), &sc->sc_lo[1]);
2094 err |= __put_user(mfhi2(), &sc->sc_hi[2]);
2095 err |= __put_user(mflo2(), &sc->sc_lo[2]);
2096 err |= __put_user(mfhi3(), &sc->sc_hi[3]);
2097 err |= __put_user(mflo3(), &sc->sc_lo[3]);
2098 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
2099 }
2100 #endif
2101 #endif
2102
2103 #if 0
2104 err |= __put_user(!!used_math(), &sc->sc_used_math);
2105
2106 if (!used_math())
2107 goto out;
2108
2109 /*
2110 * Save FPU state to signal context. Signal handler will "inherit"
2111 * current FPU state.
2112 */
2113 preempt_disable();
2114
2115 if (!is_fpu_owner()) {
2116 own_fpu();
2117 restore_fp(current);
2118 }
2119 err |= save_fp_context(sc);
2120
2121 preempt_enable();
2122 out:
2123 #endif
2124 return err;
2125 }
2126
2127 static inline int
2128 restore_sigcontext(CPUState *regs, struct target_sigcontext *sc)
2129 {
2130 int err = 0;
2131
2132 err |= __get_user(regs->CP0_EPC, &sc->sc_pc);
2133
2134 err |= __get_user(regs->HI[0][regs->current_tc], &sc->sc_mdhi);
2135 err |= __get_user(regs->LO[0][regs->current_tc], &sc->sc_mdlo);
2136
2137 #define restore_gp_reg(i) do { \
2138 err |= __get_user(regs->gpr[i][regs->current_tc], &sc->sc_regs[i]); \
2139 } while(0)
2140 restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
2141 restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
2142 restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
2143 restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
2144 restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
2145 restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
2146 restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
2147 restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
2148 restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
2149 restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
2150 restore_gp_reg(31);
2151 #undef restore_gp_reg
2152
2153 #if 0
2154 if (cpu_has_dsp) {
2155 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
2156 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
2157 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
2158 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
2159 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
2160 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
2161 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
2162 }
2163 #ifdef CONFIG_64BIT
2164 err |= __get_user(regs->hi, &sc->sc_hi[0]);
2165 err |= __get_user(regs->lo, &sc->sc_lo[0]);
2166 if (cpu_has_dsp) {
2167 err |= __get_user(treg, &sc->sc_hi[1]); mthi1(treg);
2168 err |= __get_user(treg, &sc->sc_lo[1]); mthi1(treg);
2169 err |= __get_user(treg, &sc->sc_hi[2]); mthi2(treg);
2170 err |= __get_user(treg, &sc->sc_lo[2]); mthi2(treg);
2171 err |= __get_user(treg, &sc->sc_hi[3]); mthi3(treg);
2172 err |= __get_user(treg, &sc->sc_lo[3]); mthi3(treg);
2173 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
2174 }
2175 #endif
2176
2177 err |= __get_user(used_math, &sc->sc_used_math);
2178 conditional_used_math(used_math);
2179
2180 preempt_disable();
2181
2182 if (used_math()) {
2183 /* restore fpu context if we have used it before */
2184 own_fpu();
2185 err |= restore_fp_context(sc);
2186 } else {
2187 /* signal handler may have used FPU. Give it up. */
2188 lose_fpu();
2189 }
2190
2191 preempt_enable();
2192 #endif
2193 return err;
2194 }
2195 /*
2196 * Determine which stack to use..
2197 */
2198 static inline void *
2199 get_sigframe(struct emulated_sigaction *ka, CPUState *regs, size_t frame_size)
2200 {
2201 unsigned long sp;
2202
2203 /* Default to using normal stack */
2204 sp = regs->gpr[29][regs->current_tc];
2205
2206 /*
2207 * FPU emulator may have it's own trampoline active just
2208 * above the user stack, 16-bytes before the next lowest
2209 * 16 byte boundary. Try to avoid trashing it.
2210 */
2211 sp -= 32;
2212
2213 /* This is the X/Open sanctioned signal stack switching. */
2214 if ((ka->sa.sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
2215 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
2216 }
2217
2218 return g2h((sp - frame_size) & ~7);
2219 }
2220
2221 static void setup_frame(int sig, struct emulated_sigaction * ka,
2222 target_sigset_t *set, CPUState *regs)
2223 {
2224 struct sigframe *frame;
2225 int i;
2226
2227 frame = get_sigframe(ka, regs, sizeof(*frame));
2228 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
2229 goto give_sigsegv;
2230
2231 install_sigtramp(frame->sf_code, TARGET_NR_sigreturn);
2232
2233 if(setup_sigcontext(regs, &frame->sf_sc))
2234 goto give_sigsegv;
2235
2236 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2237 if(__put_user(set->sig[i], &frame->sf_mask.sig[i]))
2238 goto give_sigsegv;
2239 }
2240
2241 /*
2242 * Arguments to signal handler:
2243 *
2244 * a0 = signal number
2245 * a1 = 0 (should be cause)
2246 * a2 = pointer to struct sigcontext
2247 *
2248 * $25 and PC point to the signal handler, $29 points to the
2249 * struct sigframe.
2250 */
2251 regs->gpr[ 4][regs->current_tc] = sig;
2252 regs->gpr[ 5][regs->current_tc] = 0;
2253 regs->gpr[ 6][regs->current_tc] = h2g(&frame->sf_sc);
2254 regs->gpr[29][regs->current_tc] = h2g(frame);
2255 regs->gpr[31][regs->current_tc] = h2g(frame->sf_code);
2256 /* The original kernel code sets CP0_EPC to the handler
2257 * since it returns to userland using eret
2258 * we cannot do this here, and we must set PC directly */
2259 regs->PC[regs->current_tc] = regs->gpr[25][regs->current_tc] = ka->sa._sa_handler;
2260 return;
2261
2262 give_sigsegv:
2263 force_sig(TARGET_SIGSEGV/*, current*/);
2264 return;
2265 }
2266
2267 long do_sigreturn(CPUState *regs)
2268 {
2269 struct sigframe *frame;
2270 sigset_t blocked;
2271 target_sigset_t target_set;
2272 int i;
2273
2274 #if defined(DEBUG_SIGNAL)
2275 fprintf(stderr, "do_sigreturn\n");
2276 #endif
2277 frame = (struct sigframe *) regs->gpr[29][regs->current_tc];
2278 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
2279 goto badframe;
2280
2281 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2282 if(__get_user(target_set.sig[i], &frame->sf_mask.sig[i]))
2283 goto badframe;
2284 }
2285
2286 target_to_host_sigset_internal(&blocked, &target_set);
2287 sigprocmask(SIG_SETMASK, &blocked, NULL);
2288
2289 if (restore_sigcontext(regs, &frame->sf_sc))
2290 goto badframe;
2291
2292 #if 0
2293 /*
2294 * Don't let your children do this ...
2295 */
2296 __asm__ __volatile__(
2297 "move\t$29, %0\n\t"
2298 "j\tsyscall_exit"
2299 :/* no outputs */
2300 :"r" (&regs));
2301 /* Unreached */
2302 #endif
2303
2304 regs->PC[regs->current_tc] = regs->CP0_EPC;
2305 /* I am not sure this is right, but it seems to work
2306 * maybe a problem with nested signals ? */
2307 regs->CP0_EPC = 0;
2308 return 0;
2309
2310 badframe:
2311 force_sig(TARGET_SIGSEGV/*, current*/);
2312 return 0;
2313 }
2314
2315 static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
2316 target_siginfo_t *info,
2317 target_sigset_t *set, CPUState *env)
2318 {
2319 fprintf(stderr, "setup_rt_frame: not implemented\n");
2320 }
2321
2322 long do_rt_sigreturn(CPUState *env)
2323 {
2324 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
2325 return -ENOSYS;
2326 }
2327
2328 #else
2329
2330 static void setup_frame(int sig, struct emulated_sigaction *ka,
2331 target_sigset_t *set, CPUState *env)
2332 {
2333 fprintf(stderr, "setup_frame: not implemented\n");
2334 }
2335
2336 static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
2337 target_siginfo_t *info,
2338 target_sigset_t *set, CPUState *env)
2339 {
2340 fprintf(stderr, "setup_rt_frame: not implemented\n");
2341 }
2342
2343 long do_sigreturn(CPUState *env)
2344 {
2345 fprintf(stderr, "do_sigreturn: not implemented\n");
2346 return -ENOSYS;
2347 }
2348
2349 long do_rt_sigreturn(CPUState *env)
2350 {
2351 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
2352 return -ENOSYS;
2353 }
2354
2355 #endif
2356
2357 void process_pending_signals(void *cpu_env)
2358 {
2359 int sig;
2360 abi_ulong handler;
2361 sigset_t set, old_set;
2362 target_sigset_t target_old_set;
2363 struct emulated_sigaction *k;
2364 struct sigqueue *q;
2365
2366 if (!signal_pending)
2367 return;
2368
2369 k = sigact_table;
2370 for(sig = 1; sig <= TARGET_NSIG; sig++) {
2371 if (k->pending)
2372 goto handle_signal;
2373 k++;
2374 }
2375 /* if no signal is pending, just return */
2376 signal_pending = 0;
2377 return;
2378
2379 handle_signal:
2380 #ifdef DEBUG_SIGNAL
2381 fprintf(stderr, "qemu: process signal %d\n", sig);
2382 #endif
2383 /* dequeue signal */
2384 q = k->first;
2385 k->first = q->next;
2386 if (!k->first)
2387 k->pending = 0;
2388
2389 sig = gdb_handlesig (cpu_env, sig);
2390 if (!sig) {
2391 fprintf (stderr, "Lost signal\n");
2392 abort();
2393 }
2394
2395 handler = k->sa._sa_handler;
2396 if (handler == TARGET_SIG_DFL) {
2397 /* default handler : ignore some signal. The other are fatal */
2398 if (sig != TARGET_SIGCHLD &&
2399 sig != TARGET_SIGURG &&
2400 sig != TARGET_SIGWINCH) {
2401 force_sig(sig);
2402 }
2403 } else if (handler == TARGET_SIG_IGN) {
2404 /* ignore sig */
2405 } else if (handler == TARGET_SIG_ERR) {
2406 force_sig(sig);
2407 } else {
2408 /* compute the blocked signals during the handler execution */
2409 target_to_host_sigset(&set, &k->sa.sa_mask);
2410 /* SA_NODEFER indicates that the current signal should not be
2411 blocked during the handler */
2412 if (!(k->sa.sa_flags & TARGET_SA_NODEFER))
2413 sigaddset(&set, target_to_host_signal(sig));
2414
2415 /* block signals in the handler using Linux */
2416 sigprocmask(SIG_BLOCK, &set, &old_set);
2417 /* save the previous blocked signal state to restore it at the
2418 end of the signal execution (see do_sigreturn) */
2419 host_to_target_sigset_internal(&target_old_set, &old_set);
2420
2421 /* if the CPU is in VM86 mode, we restore the 32 bit values */
2422 #if defined(TARGET_I386) && !defined(TARGET_X86_64)
2423 {
2424 CPUX86State *env = cpu_env;
2425 if (env->eflags & VM_MASK)
2426 save_v86_state(env);
2427 }
2428 #endif
2429 /* prepare the stack frame of the virtual CPU */
2430 if (k->sa.sa_flags & TARGET_SA_SIGINFO)
2431 setup_rt_frame(sig, k, &q->info, &target_old_set, cpu_env);
2432 else
2433 setup_frame(sig, k, &target_old_set, cpu_env);
2434 if (k->sa.sa_flags & TARGET_SA_RESETHAND)
2435 k->sa._sa_handler = TARGET_SIG_DFL;
2436 }
2437 if (q != &k->info)
2438 free_sigqueue(q);
2439 }
Stable branch of Qemu 0.9.1