2 * Emulation of Linux signals
4 * Copyright (c) 2003 Fabrice Bellard
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.
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.
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.
27 #include <sys/ucontext.h>
31 //#define DEBUG_SIGNAL
33 #define MAX_SIGQUEUE_SIZE 1024
36 struct sigqueue
*next
;
37 target_siginfo_t info
;
40 struct emulated_sigaction
{
41 struct target_sigaction sa
;
42 int pending
; /* true if signal is pending */
43 struct sigqueue
*first
;
44 struct sigqueue info
; /* in order to always have memory for the
45 first signal, we put it here */
48 static struct emulated_sigaction sigact_table
[TARGET_NSIG
];
49 static struct sigqueue sigqueue_table
[MAX_SIGQUEUE_SIZE
]; /* siginfo queue */
50 static struct sigqueue
*first_free
; /* first free siginfo queue entry */
51 static int signal_pending
; /* non zero if a signal may be pending */
53 static void host_signal_handler(int host_signum
, siginfo_t
*info
,
56 static uint8_t host_to_target_signal_table
[65] = {
57 [SIGHUP
] = TARGET_SIGHUP
,
58 [SIGINT
] = TARGET_SIGINT
,
59 [SIGQUIT
] = TARGET_SIGQUIT
,
60 [SIGILL
] = TARGET_SIGILL
,
61 [SIGTRAP
] = TARGET_SIGTRAP
,
62 [SIGABRT
] = TARGET_SIGABRT
,
63 /* [SIGIOT] = TARGET_SIGIOT,*/
64 [SIGBUS
] = TARGET_SIGBUS
,
65 [SIGFPE
] = TARGET_SIGFPE
,
66 [SIGKILL
] = TARGET_SIGKILL
,
67 [SIGUSR1
] = TARGET_SIGUSR1
,
68 [SIGSEGV
] = TARGET_SIGSEGV
,
69 [SIGUSR2
] = TARGET_SIGUSR2
,
70 [SIGPIPE
] = TARGET_SIGPIPE
,
71 [SIGALRM
] = TARGET_SIGALRM
,
72 [SIGTERM
] = TARGET_SIGTERM
,
74 [SIGSTKFLT
] = TARGET_SIGSTKFLT
,
76 [SIGCHLD
] = TARGET_SIGCHLD
,
77 [SIGCONT
] = TARGET_SIGCONT
,
78 [SIGSTOP
] = TARGET_SIGSTOP
,
79 [SIGTSTP
] = TARGET_SIGTSTP
,
80 [SIGTTIN
] = TARGET_SIGTTIN
,
81 [SIGTTOU
] = TARGET_SIGTTOU
,
82 [SIGURG
] = TARGET_SIGURG
,
83 [SIGXCPU
] = TARGET_SIGXCPU
,
84 [SIGXFSZ
] = TARGET_SIGXFSZ
,
85 [SIGVTALRM
] = TARGET_SIGVTALRM
,
86 [SIGPROF
] = TARGET_SIGPROF
,
87 [SIGWINCH
] = TARGET_SIGWINCH
,
88 [SIGIO
] = TARGET_SIGIO
,
89 [SIGPWR
] = TARGET_SIGPWR
,
90 [SIGSYS
] = TARGET_SIGSYS
,
91 /* next signals stay the same */
93 static uint8_t target_to_host_signal_table
[65];
95 static inline int host_to_target_signal(int sig
)
97 return host_to_target_signal_table
[sig
];
100 static inline int target_to_host_signal(int sig
)
102 return target_to_host_signal_table
[sig
];
105 static void host_to_target_sigset_internal(target_sigset_t
*d
,
109 unsigned long sigmask
;
110 uint32_t target_sigmask
;
112 sigmask
= ((unsigned long *)s
)[0];
114 for(i
= 0; i
< 32; i
++) {
115 if (sigmask
& (1 << i
))
116 target_sigmask
|= 1 << (host_to_target_signal(i
+ 1) - 1);
118 #if TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 32
119 d
->sig
[0] = target_sigmask
;
120 for(i
= 1;i
< TARGET_NSIG_WORDS
; i
++) {
121 d
->sig
[i
] = ((unsigned long *)s
)[i
];
123 #elif TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 64 && TARGET_NSIG_WORDS == 2
124 d
->sig
[0] = target_sigmask
;
125 d
->sig
[1] = sigmask
>> 32;
127 #warning host_to_target_sigset
131 void host_to_target_sigset(target_sigset_t
*d
, const sigset_t
*s
)
136 host_to_target_sigset_internal(&d1
, s
);
137 for(i
= 0;i
< TARGET_NSIG_WORDS
; i
++)
138 d
->sig
[i
] = tswapl(d1
.sig
[i
]);
141 void target_to_host_sigset_internal(sigset_t
*d
, const target_sigset_t
*s
)
144 unsigned long sigmask
;
145 target_ulong target_sigmask
;
147 target_sigmask
= s
->sig
[0];
149 for(i
= 0; i
< 32; i
++) {
150 if (target_sigmask
& (1 << i
))
151 sigmask
|= 1 << (target_to_host_signal(i
+ 1) - 1);
153 #if TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 32
154 ((unsigned long *)d
)[0] = sigmask
;
155 for(i
= 1;i
< TARGET_NSIG_WORDS
; i
++) {
156 ((unsigned long *)d
)[i
] = s
->sig
[i
];
158 #elif TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 64 && TARGET_NSIG_WORDS == 2
159 ((unsigned long *)d
)[0] = sigmask
| ((unsigned long)(s
->sig
[1]) << 32);
161 #warning target_to_host_sigset
162 #endif /* TARGET_LONG_BITS */
165 void target_to_host_sigset(sigset_t
*d
, const target_sigset_t
*s
)
170 for(i
= 0;i
< TARGET_NSIG_WORDS
; i
++)
171 s1
.sig
[i
] = tswapl(s
->sig
[i
]);
172 target_to_host_sigset_internal(d
, &s1
);
175 void host_to_target_old_sigset(target_ulong
*old_sigset
,
176 const sigset_t
*sigset
)
179 host_to_target_sigset(&d
, sigset
);
180 *old_sigset
= d
.sig
[0];
183 void target_to_host_old_sigset(sigset_t
*sigset
,
184 const target_ulong
*old_sigset
)
189 d
.sig
[0] = *old_sigset
;
190 for(i
= 1;i
< TARGET_NSIG_WORDS
; i
++)
192 target_to_host_sigset(sigset
, &d
);
195 /* siginfo conversion */
197 static inline void host_to_target_siginfo_noswap(target_siginfo_t
*tinfo
,
198 const siginfo_t
*info
)
201 sig
= host_to_target_signal(info
->si_signo
);
202 tinfo
->si_signo
= sig
;
205 if (sig
== SIGILL
|| sig
== SIGFPE
|| sig
== SIGSEGV
||
206 sig
== SIGBUS
|| sig
== SIGTRAP
) {
207 /* should never come here, but who knows. The information for
208 the target is irrelevant */
209 tinfo
->_sifields
._sigfault
._addr
= 0;
210 } else if (sig
>= TARGET_SIGRTMIN
) {
211 tinfo
->_sifields
._rt
._pid
= info
->si_pid
;
212 tinfo
->_sifields
._rt
._uid
= info
->si_uid
;
213 /* XXX: potential problem if 64 bit */
214 tinfo
->_sifields
._rt
._sigval
.sival_ptr
=
215 (target_ulong
)info
->si_value
.sival_ptr
;
219 static void tswap_siginfo(target_siginfo_t
*tinfo
,
220 const target_siginfo_t
*info
)
223 sig
= info
->si_signo
;
224 tinfo
->si_signo
= tswap32(sig
);
225 tinfo
->si_errno
= tswap32(info
->si_errno
);
226 tinfo
->si_code
= tswap32(info
->si_code
);
227 if (sig
== SIGILL
|| sig
== SIGFPE
|| sig
== SIGSEGV
||
228 sig
== SIGBUS
|| sig
== SIGTRAP
) {
229 tinfo
->_sifields
._sigfault
._addr
=
230 tswapl(info
->_sifields
._sigfault
._addr
);
231 } else if (sig
>= TARGET_SIGRTMIN
) {
232 tinfo
->_sifields
._rt
._pid
= tswap32(info
->_sifields
._rt
._pid
);
233 tinfo
->_sifields
._rt
._uid
= tswap32(info
->_sifields
._rt
._uid
);
234 tinfo
->_sifields
._rt
._sigval
.sival_ptr
=
235 tswapl(info
->_sifields
._rt
._sigval
.sival_ptr
);
240 void host_to_target_siginfo(target_siginfo_t
*tinfo
, const siginfo_t
*info
)
242 host_to_target_siginfo_noswap(tinfo
, info
);
243 tswap_siginfo(tinfo
, tinfo
);
246 /* XXX: we support only POSIX RT signals are used. */
247 /* XXX: find a solution for 64 bit (additionnal malloced data is needed) */
248 void target_to_host_siginfo(siginfo_t
*info
, const target_siginfo_t
*tinfo
)
250 info
->si_signo
= tswap32(tinfo
->si_signo
);
251 info
->si_errno
= tswap32(tinfo
->si_errno
);
252 info
->si_code
= tswap32(tinfo
->si_code
);
253 info
->si_pid
= tswap32(tinfo
->_sifields
._rt
._pid
);
254 info
->si_uid
= tswap32(tinfo
->_sifields
._rt
._uid
);
255 info
->si_value
.sival_ptr
=
256 (void *)tswapl(tinfo
->_sifields
._rt
._sigval
.sival_ptr
);
259 void signal_init(void)
261 struct sigaction act
;
264 /* generate signal conversion tables */
265 for(i
= 1; i
<= 64; i
++) {
266 if (host_to_target_signal_table
[i
] == 0)
267 host_to_target_signal_table
[i
] = i
;
269 for(i
= 1; i
<= 64; i
++) {
270 j
= host_to_target_signal_table
[i
];
271 target_to_host_signal_table
[j
] = i
;
274 /* set all host signal handlers. ALL signals are blocked during
275 the handlers to serialize them. */
276 sigfillset(&act
.sa_mask
);
277 act
.sa_flags
= SA_SIGINFO
;
278 act
.sa_sigaction
= host_signal_handler
;
279 for(i
= 1; i
< NSIG
; i
++) {
280 sigaction(i
, &act
, NULL
);
283 memset(sigact_table
, 0, sizeof(sigact_table
));
285 first_free
= &sigqueue_table
[0];
286 for(i
= 0; i
< MAX_SIGQUEUE_SIZE
- 1; i
++)
287 sigqueue_table
[i
].next
= &sigqueue_table
[i
+ 1];
288 sigqueue_table
[MAX_SIGQUEUE_SIZE
- 1].next
= NULL
;
291 /* signal queue handling */
293 static inline struct sigqueue
*alloc_sigqueue(void)
295 struct sigqueue
*q
= first_free
;
298 first_free
= q
->next
;
302 static inline void free_sigqueue(struct sigqueue
*q
)
304 q
->next
= first_free
;
308 /* abort execution with signal */
309 void __attribute((noreturn
)) force_sig(int sig
)
312 host_sig
= target_to_host_signal(sig
);
313 fprintf(stderr
, "qemu: uncaught target signal %d (%s) - exiting\n",
314 sig
, strsignal(host_sig
));
319 struct sigaction act
;
320 sigemptyset(&act
.sa_mask
);
321 act
.sa_flags
= SA_SIGINFO
;
322 act
.sa_sigaction
= SIG_DFL
;
323 sigaction(SIGABRT
, &act
, NULL
);
329 /* queue a signal so that it will be send to the virtual CPU as soon
331 int queue_signal(int sig
, target_siginfo_t
*info
)
333 struct emulated_sigaction
*k
;
334 struct sigqueue
*q
, **pq
;
335 target_ulong handler
;
337 #if defined(DEBUG_SIGNAL)
338 fprintf(stderr
, "queue_signal: sig=%d\n",
341 k
= &sigact_table
[sig
- 1];
342 handler
= k
->sa
._sa_handler
;
343 if (handler
== TARGET_SIG_DFL
) {
344 /* default handler : ignore some signal. The other are fatal */
345 if (sig
!= TARGET_SIGCHLD
&&
346 sig
!= TARGET_SIGURG
&&
347 sig
!= TARGET_SIGWINCH
) {
350 return 0; /* indicate ignored */
352 } else if (handler
== TARGET_SIG_IGN
) {
355 } else if (handler
== TARGET_SIG_ERR
) {
359 if (sig
< TARGET_SIGRTMIN
) {
360 /* if non real time signal, we queue exactly one signal */
370 q
= alloc_sigqueue();
381 /* signal that a new signal is pending */
383 return 1; /* indicates that the signal was queued */
387 static void host_signal_handler(int host_signum
, siginfo_t
*info
,
391 target_siginfo_t tinfo
;
393 /* the CPU emulator uses some host signals to detect exceptions,
394 we we forward to it some signals */
395 if (host_signum
== SIGSEGV
|| host_signum
== SIGBUS
396 #if defined(TARGET_I386) && defined(USE_CODE_COPY)
397 || host_signum
== SIGFPE
400 if (cpu_signal_handler(host_signum
, info
, puc
))
404 /* get target signal number */
405 sig
= host_to_target_signal(host_signum
);
406 if (sig
< 1 || sig
> TARGET_NSIG
)
408 #if defined(DEBUG_SIGNAL)
409 fprintf(stderr
, "qemu: got signal %d\n", sig
);
411 host_to_target_siginfo_noswap(&tinfo
, info
);
412 if (queue_signal(sig
, &tinfo
) == 1) {
413 /* interrupt the virtual CPU as soon as possible */
414 cpu_interrupt(global_env
, CPU_INTERRUPT_EXIT
);
418 int do_sigaction(int sig
, const struct target_sigaction
*act
,
419 struct target_sigaction
*oact
)
421 struct emulated_sigaction
*k
;
422 struct sigaction act1
;
425 if (sig
< 1 || sig
> TARGET_NSIG
)
427 k
= &sigact_table
[sig
- 1];
428 #if defined(DEBUG_SIGNAL)
429 fprintf(stderr
, "sigaction sig=%d act=0x%08x, oact=0x%08x\n",
430 sig
, (int)act
, (int)oact
);
433 oact
->_sa_handler
= tswapl(k
->sa
._sa_handler
);
434 oact
->sa_flags
= tswapl(k
->sa
.sa_flags
);
435 #if !defined(TARGET_MIPS)
436 oact
->sa_restorer
= tswapl(k
->sa
.sa_restorer
);
438 oact
->sa_mask
= k
->sa
.sa_mask
;
441 k
->sa
._sa_handler
= tswapl(act
->_sa_handler
);
442 k
->sa
.sa_flags
= tswapl(act
->sa_flags
);
443 #if !defined(TARGET_MIPS)
444 k
->sa
.sa_restorer
= tswapl(act
->sa_restorer
);
446 k
->sa
.sa_mask
= act
->sa_mask
;
448 /* we update the host linux signal state */
449 host_sig
= target_to_host_signal(sig
);
450 if (host_sig
!= SIGSEGV
&& host_sig
!= SIGBUS
) {
451 sigfillset(&act1
.sa_mask
);
452 act1
.sa_flags
= SA_SIGINFO
;
453 if (k
->sa
.sa_flags
& TARGET_SA_RESTART
)
454 act1
.sa_flags
|= SA_RESTART
;
455 /* NOTE: it is important to update the host kernel signal
456 ignore state to avoid getting unexpected interrupted
458 if (k
->sa
._sa_handler
== TARGET_SIG_IGN
) {
459 act1
.sa_sigaction
= (void *)SIG_IGN
;
460 } else if (k
->sa
._sa_handler
== TARGET_SIG_DFL
) {
461 act1
.sa_sigaction
= (void *)SIG_DFL
;
463 act1
.sa_sigaction
= host_signal_handler
;
465 sigaction(host_sig
, &act1
, NULL
);
472 #define offsetof(type, field) ((size_t) &((type *)0)->field)
475 static inline int copy_siginfo_to_user(target_siginfo_t
*tinfo
,
476 const target_siginfo_t
*info
)
478 tswap_siginfo(tinfo
, info
);
484 /* from the Linux kernel */
486 struct target_fpreg
{
487 uint16_t significand
[4];
491 struct target_fpxreg
{
492 uint16_t significand
[4];
497 struct target_xmmreg
{
498 target_ulong element
[4];
501 struct target_fpstate
{
502 /* Regular FPU environment */
508 target_ulong dataoff
;
509 target_ulong datasel
;
510 struct target_fpreg _st
[8];
512 uint16_t magic
; /* 0xffff = regular FPU data only */
514 /* FXSR FPU environment */
515 target_ulong _fxsr_env
[6]; /* FXSR FPU env is ignored */
517 target_ulong reserved
;
518 struct target_fpxreg _fxsr_st
[8]; /* FXSR FPU reg data is ignored */
519 struct target_xmmreg _xmm
[8];
520 target_ulong padding
[56];
523 #define X86_FXSR_MAGIC 0x0000
525 struct target_sigcontext
{
543 target_ulong esp_at_signal
;
545 target_ulong fpstate
; /* pointer */
546 target_ulong oldmask
;
550 typedef struct target_sigaltstack
{
553 target_ulong ss_size
;
556 struct target_ucontext
{
557 target_ulong tuc_flags
;
558 target_ulong tuc_link
;
559 target_stack_t tuc_stack
;
560 struct target_sigcontext tuc_mcontext
;
561 target_sigset_t tuc_sigmask
; /* mask last for extensibility */
566 target_ulong pretcode
;
568 struct target_sigcontext sc
;
569 struct target_fpstate fpstate
;
570 target_ulong extramask
[TARGET_NSIG_WORDS
-1];
576 target_ulong pretcode
;
580 struct target_siginfo info
;
581 struct target_ucontext uc
;
582 struct target_fpstate fpstate
;
587 * Set up a signal frame.
590 /* XXX: save x87 state */
592 setup_sigcontext(struct target_sigcontext
*sc
, struct target_fpstate
*fpstate
,
593 CPUX86State
*env
, unsigned long mask
)
597 err
|= __put_user(env
->segs
[R_GS
].selector
, (unsigned int *)&sc
->gs
);
598 err
|= __put_user(env
->segs
[R_FS
].selector
, (unsigned int *)&sc
->fs
);
599 err
|= __put_user(env
->segs
[R_ES
].selector
, (unsigned int *)&sc
->es
);
600 err
|= __put_user(env
->segs
[R_DS
].selector
, (unsigned int *)&sc
->ds
);
601 err
|= __put_user(env
->regs
[R_EDI
], &sc
->edi
);
602 err
|= __put_user(env
->regs
[R_ESI
], &sc
->esi
);
603 err
|= __put_user(env
->regs
[R_EBP
], &sc
->ebp
);
604 err
|= __put_user(env
->regs
[R_ESP
], &sc
->esp
);
605 err
|= __put_user(env
->regs
[R_EBX
], &sc
->ebx
);
606 err
|= __put_user(env
->regs
[R_EDX
], &sc
->edx
);
607 err
|= __put_user(env
->regs
[R_ECX
], &sc
->ecx
);
608 err
|= __put_user(env
->regs
[R_EAX
], &sc
->eax
);
609 err
|= __put_user(env
->exception_index
, &sc
->trapno
);
610 err
|= __put_user(env
->error_code
, &sc
->err
);
611 err
|= __put_user(env
->eip
, &sc
->eip
);
612 err
|= __put_user(env
->segs
[R_CS
].selector
, (unsigned int *)&sc
->cs
);
613 err
|= __put_user(env
->eflags
, &sc
->eflags
);
614 err
|= __put_user(env
->regs
[R_ESP
], &sc
->esp_at_signal
);
615 err
|= __put_user(env
->segs
[R_SS
].selector
, (unsigned int *)&sc
->ss
);
617 cpu_x86_fsave(env
, (void *)fpstate
, 1);
618 fpstate
->status
= fpstate
->sw
;
619 err
|= __put_user(0xffff, &fpstate
->magic
);
620 err
|= __put_user(fpstate
, &sc
->fpstate
);
622 /* non-iBCS2 extensions.. */
623 err
|= __put_user(mask
, &sc
->oldmask
);
624 err
|= __put_user(env
->cr
[2], &sc
->cr2
);
629 * Determine which stack to use..
633 get_sigframe(struct emulated_sigaction
*ka
, CPUX86State
*env
, size_t frame_size
)
637 /* Default to using normal stack */
638 esp
= env
->regs
[R_ESP
];
640 /* This is the X/Open sanctioned signal stack switching. */
641 if (ka
->sa
.sa_flags
& SA_ONSTACK
) {
642 if (sas_ss_flags(esp
) == 0)
643 esp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
646 /* This is the legacy signal stack switching. */
649 if ((env
->segs
[R_SS
].selector
& 0xffff) != __USER_DS
&&
650 !(ka
->sa
.sa_flags
& TARGET_SA_RESTORER
) &&
651 ka
->sa
.sa_restorer
) {
652 esp
= (unsigned long) ka
->sa
.sa_restorer
;
654 return g2h((esp
- frame_size
) & -8ul);
657 static void setup_frame(int sig
, struct emulated_sigaction
*ka
,
658 target_sigset_t
*set
, CPUX86State
*env
)
660 struct sigframe
*frame
;
663 frame
= get_sigframe(ka
, env
, sizeof(*frame
));
665 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(*frame
)))
667 err
|= __put_user((/*current->exec_domain
668 && current->exec_domain->signal_invmap
670 ? current->exec_domain->signal_invmap[sig]
676 setup_sigcontext(&frame
->sc
, &frame
->fpstate
, env
, set
->sig
[0]);
680 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
681 if (__put_user(set
->sig
[i
], &frame
->extramask
[i
- 1]))
685 /* Set up to return from userspace. If provided, use a stub
686 already in userspace. */
687 if (ka
->sa
.sa_flags
& TARGET_SA_RESTORER
) {
688 err
|= __put_user(ka
->sa
.sa_restorer
, &frame
->pretcode
);
690 err
|= __put_user(frame
->retcode
, &frame
->pretcode
);
691 /* This is popl %eax ; movl $,%eax ; int $0x80 */
692 err
|= __put_user(0xb858, (short *)(frame
->retcode
+0));
693 err
|= __put_user(TARGET_NR_sigreturn
, (int *)(frame
->retcode
+2));
694 err
|= __put_user(0x80cd, (short *)(frame
->retcode
+6));
700 /* Set up registers for signal handler */
701 env
->regs
[R_ESP
] = h2g(frame
);
702 env
->eip
= (unsigned long) ka
->sa
._sa_handler
;
704 cpu_x86_load_seg(env
, R_DS
, __USER_DS
);
705 cpu_x86_load_seg(env
, R_ES
, __USER_DS
);
706 cpu_x86_load_seg(env
, R_SS
, __USER_DS
);
707 cpu_x86_load_seg(env
, R_CS
, __USER_CS
);
708 env
->eflags
&= ~TF_MASK
;
713 if (sig
== TARGET_SIGSEGV
)
714 ka
->sa
._sa_handler
= TARGET_SIG_DFL
;
715 force_sig(TARGET_SIGSEGV
/* , current */);
718 static void setup_rt_frame(int sig
, struct emulated_sigaction
*ka
,
719 target_siginfo_t
*info
,
720 target_sigset_t
*set
, CPUX86State
*env
)
722 struct rt_sigframe
*frame
;
725 frame
= get_sigframe(ka
, env
, sizeof(*frame
));
727 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(*frame
)))
730 err
|= __put_user((/*current->exec_domain
731 && current->exec_domain->signal_invmap
733 ? current->exec_domain->signal_invmap[sig]
736 err
|= __put_user((target_ulong
)&frame
->info
, &frame
->pinfo
);
737 err
|= __put_user((target_ulong
)&frame
->uc
, &frame
->puc
);
738 err
|= copy_siginfo_to_user(&frame
->info
, info
);
742 /* Create the ucontext. */
743 err
|= __put_user(0, &frame
->uc
.tuc_flags
);
744 err
|= __put_user(0, &frame
->uc
.tuc_link
);
745 err
|= __put_user(/*current->sas_ss_sp*/ 0,
746 &frame
->uc
.tuc_stack
.ss_sp
);
747 err
|= __put_user(/* sas_ss_flags(regs->esp) */ 0,
748 &frame
->uc
.tuc_stack
.ss_flags
);
749 err
|= __put_user(/* current->sas_ss_size */ 0,
750 &frame
->uc
.tuc_stack
.ss_size
);
751 err
|= setup_sigcontext(&frame
->uc
.tuc_mcontext
, &frame
->fpstate
,
753 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
754 if (__put_user(set
->sig
[i
], &frame
->uc
.tuc_sigmask
.sig
[i
]))
758 /* Set up to return from userspace. If provided, use a stub
759 already in userspace. */
760 if (ka
->sa
.sa_flags
& TARGET_SA_RESTORER
) {
761 err
|= __put_user(ka
->sa
.sa_restorer
, &frame
->pretcode
);
763 err
|= __put_user(frame
->retcode
, &frame
->pretcode
);
764 /* This is movl $,%eax ; int $0x80 */
765 err
|= __put_user(0xb8, (char *)(frame
->retcode
+0));
766 err
|= __put_user(TARGET_NR_rt_sigreturn
, (int *)(frame
->retcode
+1));
767 err
|= __put_user(0x80cd, (short *)(frame
->retcode
+5));
773 /* Set up registers for signal handler */
774 env
->regs
[R_ESP
] = (unsigned long) frame
;
775 env
->eip
= (unsigned long) ka
->sa
._sa_handler
;
777 cpu_x86_load_seg(env
, R_DS
, __USER_DS
);
778 cpu_x86_load_seg(env
, R_ES
, __USER_DS
);
779 cpu_x86_load_seg(env
, R_SS
, __USER_DS
);
780 cpu_x86_load_seg(env
, R_CS
, __USER_CS
);
781 env
->eflags
&= ~TF_MASK
;
786 if (sig
== TARGET_SIGSEGV
)
787 ka
->sa
._sa_handler
= TARGET_SIG_DFL
;
788 force_sig(TARGET_SIGSEGV
/* , current */);
792 restore_sigcontext(CPUX86State
*env
, struct target_sigcontext
*sc
, int *peax
)
794 unsigned int err
= 0;
796 cpu_x86_load_seg(env
, R_GS
, lduw(&sc
->gs
));
797 cpu_x86_load_seg(env
, R_FS
, lduw(&sc
->fs
));
798 cpu_x86_load_seg(env
, R_ES
, lduw(&sc
->es
));
799 cpu_x86_load_seg(env
, R_DS
, lduw(&sc
->ds
));
801 env
->regs
[R_EDI
] = ldl(&sc
->edi
);
802 env
->regs
[R_ESI
] = ldl(&sc
->esi
);
803 env
->regs
[R_EBP
] = ldl(&sc
->ebp
);
804 env
->regs
[R_ESP
] = ldl(&sc
->esp
);
805 env
->regs
[R_EBX
] = ldl(&sc
->ebx
);
806 env
->regs
[R_EDX
] = ldl(&sc
->edx
);
807 env
->regs
[R_ECX
] = ldl(&sc
->ecx
);
808 env
->eip
= ldl(&sc
->eip
);
810 cpu_x86_load_seg(env
, R_CS
, lduw(&sc
->cs
) | 3);
811 cpu_x86_load_seg(env
, R_SS
, lduw(&sc
->ss
) | 3);
814 unsigned int tmpflags
;
815 tmpflags
= ldl(&sc
->eflags
);
816 env
->eflags
= (env
->eflags
& ~0x40DD5) | (tmpflags
& 0x40DD5);
817 // regs->orig_eax = -1; /* disable syscall checks */
821 struct _fpstate
* buf
;
822 buf
= (void *)ldl(&sc
->fpstate
);
825 if (verify_area(VERIFY_READ
, buf
, sizeof(*buf
)))
828 cpu_x86_frstor(env
, (void *)buf
, 1);
832 *peax
= ldl(&sc
->eax
);
840 long do_sigreturn(CPUX86State
*env
)
842 struct sigframe
*frame
= (struct sigframe
*)g2h(env
->regs
[R_ESP
] - 8);
843 target_sigset_t target_set
;
847 #if defined(DEBUG_SIGNAL)
848 fprintf(stderr
, "do_sigreturn\n");
850 /* set blocked signals */
851 if (__get_user(target_set
.sig
[0], &frame
->sc
.oldmask
))
853 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
854 if (__get_user(target_set
.sig
[i
], &frame
->extramask
[i
- 1]))
858 target_to_host_sigset_internal(&set
, &target_set
);
859 sigprocmask(SIG_SETMASK
, &set
, NULL
);
861 /* restore registers */
862 if (restore_sigcontext(env
, &frame
->sc
, &eax
))
867 force_sig(TARGET_SIGSEGV
);
871 long do_rt_sigreturn(CPUX86State
*env
)
873 struct rt_sigframe
*frame
= (struct rt_sigframe
*)g2h(env
->regs
[R_ESP
] - 4);
879 if (verify_area(VERIFY_READ
, frame
, sizeof(*frame
)))
882 target_to_host_sigset(&set
, &frame
->uc
.tuc_sigmask
);
883 sigprocmask(SIG_SETMASK
, &set
, NULL
);
885 if (restore_sigcontext(env
, &frame
->uc
.tuc_mcontext
, &eax
))
889 if (__copy_from_user(&st
, &frame
->uc
.tuc_stack
, sizeof(st
)))
891 /* It is more difficult to avoid calling this function than to
892 call it and ignore errors. */
893 do_sigaltstack(&st
, NULL
, regs
->esp
);
898 force_sig(TARGET_SIGSEGV
);
902 #elif defined(TARGET_ARM)
904 struct target_sigcontext
{
905 target_ulong trap_no
;
906 target_ulong error_code
;
907 target_ulong oldmask
;
918 target_ulong arm_r10
;
924 target_ulong arm_cpsr
;
925 target_ulong fault_address
;
928 typedef struct target_sigaltstack
{
931 target_ulong ss_size
;
934 struct target_ucontext
{
935 target_ulong tuc_flags
;
936 target_ulong tuc_link
;
937 target_stack_t tuc_stack
;
938 struct target_sigcontext tuc_mcontext
;
939 target_sigset_t tuc_sigmask
; /* mask last for extensibility */
944 struct target_sigcontext sc
;
945 target_ulong extramask
[TARGET_NSIG_WORDS
-1];
946 target_ulong retcode
;
951 struct target_siginfo
*pinfo
;
953 struct target_siginfo info
;
954 struct target_ucontext uc
;
955 target_ulong retcode
;
958 #define TARGET_CONFIG_CPU_32 1
961 * For ARM syscalls, we encode the syscall number into the instruction.
963 #define SWI_SYS_SIGRETURN (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
964 #define SWI_SYS_RT_SIGRETURN (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
967 * For Thumb syscalls, we pass the syscall number via r7. We therefore
968 * need two 16-bit instructions.
970 #define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
971 #define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
973 static const target_ulong retcodes
[4] = {
974 SWI_SYS_SIGRETURN
, SWI_THUMB_SIGRETURN
,
975 SWI_SYS_RT_SIGRETURN
, SWI_THUMB_RT_SIGRETURN
979 #define __put_user_error(x,p,e) __put_user(x, p)
980 #define __get_user_error(x,p,e) __get_user(x, p)
982 static inline int valid_user_regs(CPUState
*regs
)
988 setup_sigcontext(struct target_sigcontext
*sc
, /*struct _fpstate *fpstate,*/
989 CPUState
*env
, unsigned long mask
)
993 __put_user_error(env
->regs
[0], &sc
->arm_r0
, err
);
994 __put_user_error(env
->regs
[1], &sc
->arm_r1
, err
);
995 __put_user_error(env
->regs
[2], &sc
->arm_r2
, err
);
996 __put_user_error(env
->regs
[3], &sc
->arm_r3
, err
);
997 __put_user_error(env
->regs
[4], &sc
->arm_r4
, err
);
998 __put_user_error(env
->regs
[5], &sc
->arm_r5
, err
);
999 __put_user_error(env
->regs
[6], &sc
->arm_r6
, err
);
1000 __put_user_error(env
->regs
[7], &sc
->arm_r7
, err
);
1001 __put_user_error(env
->regs
[8], &sc
->arm_r8
, err
);
1002 __put_user_error(env
->regs
[9], &sc
->arm_r9
, err
);
1003 __put_user_error(env
->regs
[10], &sc
->arm_r10
, err
);
1004 __put_user_error(env
->regs
[11], &sc
->arm_fp
, err
);
1005 __put_user_error(env
->regs
[12], &sc
->arm_ip
, err
);
1006 __put_user_error(env
->regs
[13], &sc
->arm_sp
, err
);
1007 __put_user_error(env
->regs
[14], &sc
->arm_lr
, err
);
1008 __put_user_error(env
->regs
[15], &sc
->arm_pc
, err
);
1009 #ifdef TARGET_CONFIG_CPU_32
1010 __put_user_error(cpsr_read(env
), &sc
->arm_cpsr
, err
);
1013 __put_user_error(/* current->thread.trap_no */ 0, &sc
->trap_no
, err
);
1014 __put_user_error(/* current->thread.error_code */ 0, &sc
->error_code
, err
);
1015 __put_user_error(/* current->thread.address */ 0, &sc
->fault_address
, err
);
1016 __put_user_error(mask
, &sc
->oldmask
, err
);
1021 static inline void *
1022 get_sigframe(struct emulated_sigaction
*ka
, CPUState
*regs
, int framesize
)
1024 unsigned long sp
= regs
->regs
[13];
1028 * This is the X/Open sanctioned signal stack switching.
1030 if ((ka
->sa
.sa_flags
& SA_ONSTACK
) && !sas_ss_flags(sp
))
1031 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
1034 * ATPCS B01 mandates 8-byte alignment
1036 return g2h((sp
- framesize
) & ~7);
1040 setup_return(CPUState
*env
, struct emulated_sigaction
*ka
,
1041 target_ulong
*rc
, void *frame
, int usig
)
1043 target_ulong handler
= (target_ulong
)ka
->sa
._sa_handler
;
1044 target_ulong retcode
;
1046 #if defined(TARGET_CONFIG_CPU_32)
1048 target_ulong cpsr
= env
->cpsr
;
1051 * Maybe we need to deliver a 32-bit signal to a 26-bit task.
1053 if (ka
->sa
.sa_flags
& SA_THIRTYTWO
)
1054 cpsr
= (cpsr
& ~MODE_MASK
) | USR_MODE
;
1056 #ifdef CONFIG_ARM_THUMB
1057 if (elf_hwcap
& HWCAP_THUMB
) {
1059 * The LSB of the handler determines if we're going to
1060 * be using THUMB or ARM mode for this signal handler.
1062 thumb
= handler
& 1;
1071 #endif /* TARGET_CONFIG_CPU_32 */
1073 if (ka
->sa
.sa_flags
& TARGET_SA_RESTORER
) {
1074 retcode
= (target_ulong
)ka
->sa
.sa_restorer
;
1076 unsigned int idx
= thumb
;
1078 if (ka
->sa
.sa_flags
& TARGET_SA_SIGINFO
)
1081 if (__put_user(retcodes
[idx
], rc
))
1084 flush_icache_range((target_ulong
)rc
,
1085 (target_ulong
)(rc
+ 1));
1087 retcode
= ((target_ulong
)rc
) + thumb
;
1090 env
->regs
[0] = usig
;
1091 env
->regs
[13] = h2g(frame
);
1092 env
->regs
[14] = retcode
;
1093 env
->regs
[15] = handler
& (thumb
? ~1 : ~3);
1096 #ifdef TARGET_CONFIG_CPU_32
1104 static void setup_frame(int usig
, struct emulated_sigaction
*ka
,
1105 target_sigset_t
*set
, CPUState
*regs
)
1107 struct sigframe
*frame
= get_sigframe(ka
, regs
, sizeof(*frame
));
1110 err
|= setup_sigcontext(&frame
->sc
, /*&frame->fpstate,*/ regs
, set
->sig
[0]);
1112 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
1113 if (__put_user(set
->sig
[i
], &frame
->extramask
[i
- 1]))
1118 err
= setup_return(regs
, ka
, &frame
->retcode
, frame
, usig
);
1122 static void setup_rt_frame(int usig
, struct emulated_sigaction
*ka
,
1123 target_siginfo_t
*info
,
1124 target_sigset_t
*set
, CPUState
*env
)
1126 struct rt_sigframe
*frame
= get_sigframe(ka
, env
, sizeof(*frame
));
1129 if (!access_ok(VERIFY_WRITE
, frame
, sizeof (*frame
)))
1132 __put_user_error(&frame
->info
, (target_ulong
*)&frame
->pinfo
, err
);
1133 __put_user_error(&frame
->uc
, (target_ulong
*)&frame
->puc
, err
);
1134 err
|= copy_siginfo_to_user(&frame
->info
, info
);
1136 /* Clear all the bits of the ucontext we don't use. */
1137 memset(&frame
->uc
, 0, offsetof(struct target_ucontext
, tuc_mcontext
));
1139 err
|= setup_sigcontext(&frame
->uc
.tuc_mcontext
, /*&frame->fpstate,*/
1141 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
1142 if (__put_user(set
->sig
[i
], &frame
->uc
.tuc_sigmask
.sig
[i
]))
1147 err
= setup_return(env
, ka
, &frame
->retcode
, frame
, usig
);
1151 * For realtime signals we must also set the second and third
1152 * arguments for the signal handler.
1153 * -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06
1155 env
->regs
[1] = (target_ulong
)frame
->pinfo
;
1156 env
->regs
[2] = (target_ulong
)frame
->puc
;
1163 restore_sigcontext(CPUState
*env
, struct target_sigcontext
*sc
)
1168 __get_user_error(env
->regs
[0], &sc
->arm_r0
, err
);
1169 __get_user_error(env
->regs
[1], &sc
->arm_r1
, err
);
1170 __get_user_error(env
->regs
[2], &sc
->arm_r2
, err
);
1171 __get_user_error(env
->regs
[3], &sc
->arm_r3
, err
);
1172 __get_user_error(env
->regs
[4], &sc
->arm_r4
, err
);
1173 __get_user_error(env
->regs
[5], &sc
->arm_r5
, err
);
1174 __get_user_error(env
->regs
[6], &sc
->arm_r6
, err
);
1175 __get_user_error(env
->regs
[7], &sc
->arm_r7
, err
);
1176 __get_user_error(env
->regs
[8], &sc
->arm_r8
, err
);
1177 __get_user_error(env
->regs
[9], &sc
->arm_r9
, err
);
1178 __get_user_error(env
->regs
[10], &sc
->arm_r10
, err
);
1179 __get_user_error(env
->regs
[11], &sc
->arm_fp
, err
);
1180 __get_user_error(env
->regs
[12], &sc
->arm_ip
, err
);
1181 __get_user_error(env
->regs
[13], &sc
->arm_sp
, err
);
1182 __get_user_error(env
->regs
[14], &sc
->arm_lr
, err
);
1183 __get_user_error(env
->regs
[15], &sc
->arm_pc
, err
);
1184 #ifdef TARGET_CONFIG_CPU_32
1185 __get_user_error(cpsr
, &sc
->arm_cpsr
, err
);
1186 cpsr_write(env
, cpsr
, 0xffffffff);
1189 err
|= !valid_user_regs(env
);
1194 long do_sigreturn(CPUState
*env
)
1196 struct sigframe
*frame
;
1197 target_sigset_t set
;
1202 * Since we stacked the signal on a 64-bit boundary,
1203 * then 'sp' should be word aligned here. If it's
1204 * not, then the user is trying to mess with us.
1206 if (env
->regs
[13] & 7)
1209 frame
= (struct sigframe
*)g2h(env
->regs
[13]);
1212 if (verify_area(VERIFY_READ
, frame
, sizeof (*frame
)))
1215 if (__get_user(set
.sig
[0], &frame
->sc
.oldmask
))
1217 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
1218 if (__get_user(set
.sig
[i
], &frame
->extramask
[i
- 1]))
1222 target_to_host_sigset_internal(&host_set
, &set
);
1223 sigprocmask(SIG_SETMASK
, &host_set
, NULL
);
1225 if (restore_sigcontext(env
, &frame
->sc
))
1229 /* Send SIGTRAP if we're single-stepping */
1230 if (ptrace_cancel_bpt(current
))
1231 send_sig(SIGTRAP
, current
, 1);
1233 return env
->regs
[0];
1236 force_sig(SIGSEGV
/* , current */);
1240 long do_rt_sigreturn(CPUState
*env
)
1242 struct rt_sigframe
*frame
;
1246 * Since we stacked the signal on a 64-bit boundary,
1247 * then 'sp' should be word aligned here. If it's
1248 * not, then the user is trying to mess with us.
1250 if (env
->regs
[13] & 7)
1253 frame
= (struct rt_sigframe
*)env
->regs
[13];
1256 if (verify_area(VERIFY_READ
, frame
, sizeof (*frame
)))
1259 target_to_host_sigset(&host_set
, &frame
->uc
.tuc_sigmask
);
1260 sigprocmask(SIG_SETMASK
, &host_set
, NULL
);
1262 if (restore_sigcontext(env
, &frame
->uc
.tuc_mcontext
))
1266 /* Send SIGTRAP if we're single-stepping */
1267 if (ptrace_cancel_bpt(current
))
1268 send_sig(SIGTRAP
, current
, 1);
1270 return env
->regs
[0];
1273 force_sig(SIGSEGV
/* , current */);
1277 #elif defined(TARGET_SPARC)
1279 #define __SUNOS_MAXWIN 31
1281 /* This is what SunOS does, so shall I. */
1282 struct target_sigcontext
{
1283 target_ulong sigc_onstack
; /* state to restore */
1285 target_ulong sigc_mask
; /* sigmask to restore */
1286 target_ulong sigc_sp
; /* stack pointer */
1287 target_ulong sigc_pc
; /* program counter */
1288 target_ulong sigc_npc
; /* next program counter */
1289 target_ulong sigc_psr
; /* for condition codes etc */
1290 target_ulong sigc_g1
; /* User uses these two registers */
1291 target_ulong sigc_o0
; /* within the trampoline code. */
1293 /* Now comes information regarding the users window set
1294 * at the time of the signal.
1296 target_ulong sigc_oswins
; /* outstanding windows */
1298 /* stack ptrs for each regwin buf */
1299 char *sigc_spbuf
[__SUNOS_MAXWIN
];
1301 /* Windows to restore after signal */
1303 target_ulong locals
[8];
1304 target_ulong ins
[8];
1305 } sigc_wbuf
[__SUNOS_MAXWIN
];
1307 /* A Sparc stack frame */
1308 struct sparc_stackf
{
1309 target_ulong locals
[8];
1310 target_ulong ins
[6];
1311 struct sparc_stackf
*fp
;
1312 target_ulong callers_pc
;
1314 target_ulong xargs
[6];
1315 target_ulong xxargs
[1];
1324 target_ulong u_regs
[16]; /* globals and ins */
1330 unsigned long si_float_regs
[32];
1331 unsigned long si_fsr
;
1332 unsigned long si_fpqdepth
;
1334 unsigned long *insn_addr
;
1337 } qemu_siginfo_fpu_t
;
1340 struct target_signal_frame
{
1341 struct sparc_stackf ss
;
1343 qemu_siginfo_fpu_t
*fpu_save
;
1344 target_ulong insns
[2] __attribute__ ((aligned (8)));
1345 target_ulong extramask
[TARGET_NSIG_WORDS
- 1];
1346 target_ulong extra_size
; /* Should be 0 */
1347 qemu_siginfo_fpu_t fpu_state
;
1349 struct target_rt_signal_frame
{
1350 struct sparc_stackf ss
;
1352 target_ulong regs
[20];
1354 qemu_siginfo_fpu_t
*fpu_save
;
1355 unsigned int insns
[2];
1357 unsigned int extra_size
; /* Should be 0 */
1358 qemu_siginfo_fpu_t fpu_state
;
1369 #define UREG_FP UREG_I6
1370 #define UREG_SP UREG_O6
1372 static inline void *get_sigframe(struct emulated_sigaction
*sa
, CPUState
*env
, unsigned long framesize
)
1376 sp
= env
->regwptr
[UREG_FP
];
1379 /* This is the X/Open sanctioned signal stack switching. */
1380 if (sa
->sa_flags
& TARGET_SA_ONSTACK
) {
1381 if (!on_sig_stack(sp
) && !((current
->sas_ss_sp
+ current
->sas_ss_size
) & 7))
1382 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
1385 return g2h(sp
- framesize
);
1389 setup___siginfo(__siginfo_t
*si
, CPUState
*env
, target_ulong mask
)
1393 err
|= __put_user(env
->psr
, &si
->si_regs
.psr
);
1394 err
|= __put_user(env
->pc
, &si
->si_regs
.pc
);
1395 err
|= __put_user(env
->npc
, &si
->si_regs
.npc
);
1396 err
|= __put_user(env
->y
, &si
->si_regs
.y
);
1397 for (i
=0; i
< 8; i
++) {
1398 err
|= __put_user(env
->gregs
[i
], &si
->si_regs
.u_regs
[i
]);
1400 for (i
=0; i
< 8; i
++) {
1401 err
|= __put_user(env
->regwptr
[UREG_I0
+ i
], &si
->si_regs
.u_regs
[i
+8]);
1403 err
|= __put_user(mask
, &si
->si_mask
);
1409 setup_sigcontext(struct target_sigcontext
*sc
, /*struct _fpstate *fpstate,*/
1410 CPUState
*env
, unsigned long mask
)
1414 err
|= __put_user(mask
, &sc
->sigc_mask
);
1415 err
|= __put_user(env
->regwptr
[UREG_SP
], &sc
->sigc_sp
);
1416 err
|= __put_user(env
->pc
, &sc
->sigc_pc
);
1417 err
|= __put_user(env
->npc
, &sc
->sigc_npc
);
1418 err
|= __put_user(env
->psr
, &sc
->sigc_psr
);
1419 err
|= __put_user(env
->gregs
[1], &sc
->sigc_g1
);
1420 err
|= __put_user(env
->regwptr
[UREG_O0
], &sc
->sigc_o0
);
1425 #define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7)))
1427 static void setup_frame(int sig
, struct emulated_sigaction
*ka
,
1428 target_sigset_t
*set
, CPUState
*env
)
1430 struct target_signal_frame
*sf
;
1431 int sigframe_size
, err
, i
;
1433 /* 1. Make sure everything is clean */
1434 //synchronize_user_stack();
1436 sigframe_size
= NF_ALIGNEDSZ
;
1438 sf
= (struct target_signal_frame
*)
1439 get_sigframe(ka
, env
, sigframe_size
);
1441 //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1443 if (invalid_frame_pointer(sf
, sigframe_size
))
1444 goto sigill_and_return
;
1446 /* 2. Save the current process state */
1447 err
= setup___siginfo(&sf
->info
, env
, set
->sig
[0]);
1448 err
|= __put_user(0, &sf
->extra_size
);
1450 //err |= save_fpu_state(regs, &sf->fpu_state);
1451 //err |= __put_user(&sf->fpu_state, &sf->fpu_save);
1453 err
|= __put_user(set
->sig
[0], &sf
->info
.si_mask
);
1454 for (i
= 0; i
< TARGET_NSIG_WORDS
- 1; i
++) {
1455 err
|= __put_user(set
->sig
[i
+ 1], &sf
->extramask
[i
]);
1458 for (i
= 0; i
< 8; i
++) {
1459 err
|= __put_user(env
->regwptr
[i
+ UREG_L0
], &sf
->ss
.locals
[i
]);
1461 for (i
= 0; i
< 8; i
++) {
1462 err
|= __put_user(env
->regwptr
[i
+ UREG_I0
], &sf
->ss
.ins
[i
]);
1467 /* 3. signal handler back-trampoline and parameters */
1468 env
->regwptr
[UREG_FP
] = h2g(sf
);
1469 env
->regwptr
[UREG_I0
] = sig
;
1470 env
->regwptr
[UREG_I1
] = h2g(&sf
->info
);
1471 env
->regwptr
[UREG_I2
] = h2g(&sf
->info
);
1473 /* 4. signal handler */
1474 env
->pc
= (unsigned long) ka
->sa
._sa_handler
;
1475 env
->npc
= (env
->pc
+ 4);
1476 /* 5. return to kernel instructions */
1477 if (ka
->sa
.sa_restorer
)
1478 env
->regwptr
[UREG_I7
] = (unsigned long)ka
->sa
.sa_restorer
;
1480 env
->regwptr
[UREG_I7
] = h2g(&(sf
->insns
[0]) - 2);
1482 /* mov __NR_sigreturn, %g1 */
1483 err
|= __put_user(0x821020d8, &sf
->insns
[0]);
1486 err
|= __put_user(0x91d02010, &sf
->insns
[1]);
1490 /* Flush instruction space. */
1491 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
1496 //sigill_and_return:
1497 force_sig(TARGET_SIGILL
);
1499 //fprintf(stderr, "force_sig\n");
1500 force_sig(TARGET_SIGSEGV
);
1503 restore_fpu_state(CPUState
*env
, qemu_siginfo_fpu_t
*fpu
)
1508 if (current
->flags
& PF_USEDFPU
)
1509 regs
->psr
&= ~PSR_EF
;
1511 if (current
== last_task_used_math
) {
1512 last_task_used_math
= 0;
1513 regs
->psr
&= ~PSR_EF
;
1516 current
->used_math
= 1;
1517 current
->flags
&= ~PF_USEDFPU
;
1520 if (verify_area (VERIFY_READ
, fpu
, sizeof(*fpu
)))
1524 err
= __copy_from_user(&env
->fpr
[0], &fpu
->si_float_regs
[0],
1525 (sizeof(unsigned long) * 32));
1526 err
|= __get_user(env
->fsr
, &fpu
->si_fsr
);
1528 err
|= __get_user(current
->thread
.fpqdepth
, &fpu
->si_fpqdepth
);
1529 if (current
->thread
.fpqdepth
!= 0)
1530 err
|= __copy_from_user(¤t
->thread
.fpqueue
[0],
1531 &fpu
->si_fpqueue
[0],
1532 ((sizeof(unsigned long) +
1533 (sizeof(unsigned long *)))*16));
1539 static void setup_rt_frame(int sig
, struct emulated_sigaction
*ka
,
1540 target_siginfo_t
*info
,
1541 target_sigset_t
*set
, CPUState
*env
)
1543 fprintf(stderr
, "setup_rt_frame: not implemented\n");
1546 long do_sigreturn(CPUState
*env
)
1548 struct target_signal_frame
*sf
;
1549 uint32_t up_psr
, pc
, npc
;
1550 target_sigset_t set
;
1552 target_ulong fpu_save
;
1555 sf
= (struct target_signal_frame
*)g2h(env
->regwptr
[UREG_FP
]);
1557 fprintf(stderr
, "sigreturn\n");
1558 fprintf(stderr
, "sf: %x pc %x fp %x sp %x\n", sf
, env
->pc
, env
->regwptr
[UREG_FP
], env
->regwptr
[UREG_SP
]);
1560 //cpu_dump_state(env, stderr, fprintf, 0);
1562 /* 1. Make sure we are not getting garbage from the user */
1564 if (verify_area (VERIFY_READ
, sf
, sizeof (*sf
)))
1568 if (((uint
) sf
) & 3)
1571 err
= __get_user(pc
, &sf
->info
.si_regs
.pc
);
1572 err
|= __get_user(npc
, &sf
->info
.si_regs
.npc
);
1577 /* 2. Restore the state */
1578 err
|= __get_user(up_psr
, &sf
->info
.si_regs
.psr
);
1580 /* User can only change condition codes and FPU enabling in %psr. */
1581 env
->psr
= (up_psr
& (PSR_ICC
/* | PSR_EF */))
1582 | (env
->psr
& ~(PSR_ICC
/* | PSR_EF */));
1586 err
|= __get_user(env
->y
, &sf
->info
.si_regs
.y
);
1587 for (i
=0; i
< 8; i
++) {
1588 err
|= __get_user(env
->gregs
[i
], &sf
->info
.si_regs
.u_regs
[i
]);
1590 for (i
=0; i
< 8; i
++) {
1591 err
|= __get_user(env
->regwptr
[i
+ UREG_I0
], &sf
->info
.si_regs
.u_regs
[i
+8]);
1594 err
|= __get_user(fpu_save
, (target_ulong
*)&sf
->fpu_save
);
1597 // err |= restore_fpu_state(env, fpu_save);
1599 /* This is pretty much atomic, no amount locking would prevent
1600 * the races which exist anyways.
1602 err
|= __get_user(set
.sig
[0], &sf
->info
.si_mask
);
1603 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
1604 err
|= (__get_user(set
.sig
[i
], &sf
->extramask
[i
- 1]));
1607 target_to_host_sigset_internal(&host_set
, &set
);
1608 sigprocmask(SIG_SETMASK
, &host_set
, NULL
);
1613 return env
->regwptr
[0];
1616 force_sig(TARGET_SIGSEGV
);
1619 long do_rt_sigreturn(CPUState
*env
)
1621 fprintf(stderr
, "do_rt_sigreturn: not implemented\n");
1625 #elif defined(TARGET_MIPS)
1627 struct target_sigcontext
{
1628 uint32_t sc_regmask
; /* Unused */
1631 uint64_t sc_regs
[32];
1632 uint64_t sc_fpregs
[32];
1633 uint32_t sc_ownedfp
; /* Unused */
1634 uint32_t sc_fpc_csr
;
1635 uint32_t sc_fpc_eir
; /* Unused */
1636 uint32_t sc_used_math
;
1637 uint32_t sc_dsp
; /* dsp status, was sc_ssflags */
1640 target_ulong sc_hi1
; /* Was sc_cause */
1641 target_ulong sc_lo1
; /* Was sc_badvaddr */
1642 target_ulong sc_hi2
; /* Was sc_sigset[4] */
1643 target_ulong sc_lo2
;
1644 target_ulong sc_hi3
;
1645 target_ulong sc_lo3
;
1649 uint32_t sf_ass
[4]; /* argument save space for o32 */
1650 uint32_t sf_code
[2]; /* signal trampoline */
1651 struct target_sigcontext sf_sc
;
1652 target_sigset_t sf_mask
;
1655 /* Install trampoline to jump back from signal handler */
1656 static inline int install_sigtramp(unsigned int *tramp
, unsigned int syscall
)
1661 * Set up the return code ...
1663 * li v0, __NR__foo_sigreturn
1667 err
= __put_user(0x24020000 + syscall
, tramp
+ 0);
1668 err
|= __put_user(0x0000000c , tramp
+ 1);
1669 /* flush_cache_sigtramp((unsigned long) tramp); */
1674 setup_sigcontext(CPUState
*regs
, struct target_sigcontext
*sc
)
1678 err
|= __put_user(regs
->PC
, &sc
->sc_pc
);
1680 #define save_gp_reg(i) do { \
1681 err |= __put_user(regs->gpr[i], &sc->sc_regs[i]); \
1683 __put_user(0, &sc
->sc_regs
[0]); save_gp_reg(1); save_gp_reg(2);
1684 save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
1685 save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
1686 save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
1687 save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
1688 save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
1689 save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
1690 save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
1694 err
|= __put_user(regs
->HI
, &sc
->sc_mdhi
);
1695 err
|= __put_user(regs
->LO
, &sc
->sc_mdlo
);
1697 /* Not used yet, but might be useful if we ever have DSP suppport */
1700 err
|= __put_user(mfhi1(), &sc
->sc_hi1
);
1701 err
|= __put_user(mflo1(), &sc
->sc_lo1
);
1702 err
|= __put_user(mfhi2(), &sc
->sc_hi2
);
1703 err
|= __put_user(mflo2(), &sc
->sc_lo2
);
1704 err
|= __put_user(mfhi3(), &sc
->sc_hi3
);
1705 err
|= __put_user(mflo3(), &sc
->sc_lo3
);
1706 err
|= __put_user(rddsp(DSP_MASK
), &sc
->sc_dsp
);
1708 /* same with 64 bit */
1710 err
|= __put_user(regs
->hi
, &sc
->sc_hi
[0]);
1711 err
|= __put_user(regs
->lo
, &sc
->sc_lo
[0]);
1713 err
|= __put_user(mfhi1(), &sc
->sc_hi
[1]);
1714 err
|= __put_user(mflo1(), &sc
->sc_lo
[1]);
1715 err
|= __put_user(mfhi2(), &sc
->sc_hi
[2]);
1716 err
|= __put_user(mflo2(), &sc
->sc_lo
[2]);
1717 err
|= __put_user(mfhi3(), &sc
->sc_hi
[3]);
1718 err
|= __put_user(mflo3(), &sc
->sc_lo
[3]);
1719 err
|= __put_user(rddsp(DSP_MASK
), &sc
->sc_dsp
);
1728 err
|= __put_user(!!used_math(), &sc
->sc_used_math
);
1734 * Save FPU state to signal context. Signal handler will "inherit"
1735 * current FPU state.
1739 if (!is_fpu_owner()) {
1741 restore_fp(current
);
1743 err
|= save_fp_context(sc
);
1752 restore_sigcontext(CPUState
*regs
, struct target_sigcontext
*sc
)
1756 err
|= __get_user(regs
->CP0_EPC
, &sc
->sc_pc
);
1758 err
|= __get_user(regs
->HI
, &sc
->sc_mdhi
);
1759 err
|= __get_user(regs
->LO
, &sc
->sc_mdlo
);
1761 #define restore_gp_reg(i) do { \
1762 err |= __get_user(regs->gpr[i], &sc->sc_regs[i]); \
1764 restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
1765 restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
1766 restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
1767 restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
1768 restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
1769 restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
1770 restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
1771 restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
1772 restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
1773 restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
1775 #undef restore_gp_reg
1779 err
|= __get_user(treg
, &sc
->sc_hi1
); mthi1(treg
);
1780 err
|= __get_user(treg
, &sc
->sc_lo1
); mtlo1(treg
);
1781 err
|= __get_user(treg
, &sc
->sc_hi2
); mthi2(treg
);
1782 err
|= __get_user(treg
, &sc
->sc_lo2
); mtlo2(treg
);
1783 err
|= __get_user(treg
, &sc
->sc_hi3
); mthi3(treg
);
1784 err
|= __get_user(treg
, &sc
->sc_lo3
); mtlo3(treg
);
1785 err
|= __get_user(treg
, &sc
->sc_dsp
); wrdsp(treg
, DSP_MASK
);
1788 err
|= __get_user(regs
->hi
, &sc
->sc_hi
[0]);
1789 err
|= __get_user(regs
->lo
, &sc
->sc_lo
[0]);
1791 err
|= __get_user(treg
, &sc
->sc_hi
[1]); mthi1(treg
);
1792 err
|= __get_user(treg
, &sc
->sc_lo
[1]); mthi1(treg
);
1793 err
|= __get_user(treg
, &sc
->sc_hi
[2]); mthi2(treg
);
1794 err
|= __get_user(treg
, &sc
->sc_lo
[2]); mthi2(treg
);
1795 err
|= __get_user(treg
, &sc
->sc_hi
[3]); mthi3(treg
);
1796 err
|= __get_user(treg
, &sc
->sc_lo
[3]); mthi3(treg
);
1797 err
|= __get_user(treg
, &sc
->sc_dsp
); wrdsp(treg
, DSP_MASK
);
1801 err
|= __get_user(used_math
, &sc
->sc_used_math
);
1802 conditional_used_math(used_math
);
1807 /* restore fpu context if we have used it before */
1809 err
|= restore_fp_context(sc
);
1811 /* signal handler may have used FPU. Give it up. */
1820 * Determine which stack to use..
1822 static inline void *
1823 get_sigframe(struct emulated_sigaction
*ka
, CPUState
*regs
, size_t frame_size
)
1827 /* Default to using normal stack */
1831 * FPU emulator may have it's own trampoline active just
1832 * above the user stack, 16-bytes before the next lowest
1833 * 16 byte boundary. Try to avoid trashing it.
1838 /* This is the X/Open sanctioned signal stack switching. */
1839 if ((ka
->sa
.sa_flags
& SA_ONSTACK
) && (sas_ss_flags (sp
) == 0))
1840 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
1843 return g2h((sp
- frame_size
) & ~7);
1846 static void setup_frame(int sig
, struct emulated_sigaction
* ka
,
1847 target_sigset_t
*set
, CPUState
*regs
)
1849 struct sigframe
*frame
;
1852 frame
= get_sigframe(ka
, regs
, sizeof(*frame
));
1853 if (!access_ok(VERIFY_WRITE
, frame
, sizeof (*frame
)))
1856 install_sigtramp(frame
->sf_code
, TARGET_NR_sigreturn
);
1858 if(setup_sigcontext(regs
, &frame
->sf_sc
))
1861 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
1862 if(__put_user(set
->sig
[i
], &frame
->sf_mask
.sig
[i
]))
1867 * Arguments to signal handler:
1869 * a0 = signal number
1870 * a1 = 0 (should be cause)
1871 * a2 = pointer to struct sigcontext
1873 * $25 and PC point to the signal handler, $29 points to the
1876 regs
->gpr
[ 4] = sig
;
1878 regs
->gpr
[ 6] = h2g(&frame
->sf_sc
);
1879 regs
->gpr
[29] = h2g(frame
);
1880 regs
->gpr
[31] = h2g(frame
->sf_code
);
1881 /* The original kernel code sets CP0_EPC to the handler
1882 * since it returns to userland using eret
1883 * we cannot do this here, and we must set PC directly */
1884 regs
->PC
= regs
->gpr
[25] = ka
->sa
._sa_handler
;
1888 force_sig(TARGET_SIGSEGV
/*, current*/);
1892 long do_sigreturn(CPUState
*regs
)
1894 struct sigframe
*frame
;
1896 target_sigset_t target_set
;
1899 #if defined(DEBUG_SIGNAL)
1900 fprintf(stderr
, "do_sigreturn\n");
1902 frame
= (struct sigframe
*) regs
->gpr
[29];
1903 if (!access_ok(VERIFY_READ
, frame
, sizeof(*frame
)))
1906 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
1907 if(__get_user(target_set
.sig
[i
], &frame
->sf_mask
.sig
[i
]))
1911 target_to_host_sigset_internal(&blocked
, &target_set
);
1912 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
1914 if (restore_sigcontext(regs
, &frame
->sf_sc
))
1919 * Don't let your children do this ...
1921 __asm__
__volatile__(
1929 regs
->PC
= regs
->CP0_EPC
;
1930 /* I am not sure this is right, but it seems to work
1931 * maybe a problem with nested signals ? */
1936 force_sig(TARGET_SIGSEGV
/*, current*/);
1941 static void setup_rt_frame(int sig
, struct emulated_sigaction
*ka
,
1942 target_siginfo_t
*info
,
1943 target_sigset_t
*set
, CPUState
*env
)
1945 fprintf(stderr
, "setup_rt_frame: not implemented\n");
1948 long do_rt_sigreturn(CPUState
*env
)
1950 fprintf(stderr
, "do_rt_sigreturn: not implemented\n");
1956 static void setup_frame(int sig
, struct emulated_sigaction
*ka
,
1957 target_sigset_t
*set
, CPUState
*env
)
1959 fprintf(stderr
, "setup_frame: not implemented\n");
1962 static void setup_rt_frame(int sig
, struct emulated_sigaction
*ka
,
1963 target_siginfo_t
*info
,
1964 target_sigset_t
*set
, CPUState
*env
)
1966 fprintf(stderr
, "setup_rt_frame: not implemented\n");
1969 long do_sigreturn(CPUState
*env
)
1971 fprintf(stderr
, "do_sigreturn: not implemented\n");
1975 long do_rt_sigreturn(CPUState
*env
)
1977 fprintf(stderr
, "do_rt_sigreturn: not implemented\n");
1983 void process_pending_signals(void *cpu_env
)
1986 target_ulong handler
;
1987 sigset_t set
, old_set
;
1988 target_sigset_t target_old_set
;
1989 struct emulated_sigaction
*k
;
1992 if (!signal_pending
)
1996 for(sig
= 1; sig
<= TARGET_NSIG
; sig
++) {
2001 /* if no signal is pending, just return */
2007 fprintf(stderr
, "qemu: process signal %d\n", sig
);
2009 /* dequeue signal */
2015 sig
= gdb_handlesig (cpu_env
, sig
);
2017 fprintf (stderr
, "Lost signal\n");
2021 handler
= k
->sa
._sa_handler
;
2022 if (handler
== TARGET_SIG_DFL
) {
2023 /* default handler : ignore some signal. The other are fatal */
2024 if (sig
!= TARGET_SIGCHLD
&&
2025 sig
!= TARGET_SIGURG
&&
2026 sig
!= TARGET_SIGWINCH
) {
2029 } else if (handler
== TARGET_SIG_IGN
) {
2031 } else if (handler
== TARGET_SIG_ERR
) {
2034 /* compute the blocked signals during the handler execution */
2035 target_to_host_sigset(&set
, &k
->sa
.sa_mask
);
2036 /* SA_NODEFER indicates that the current signal should not be
2037 blocked during the handler */
2038 if (!(k
->sa
.sa_flags
& TARGET_SA_NODEFER
))
2039 sigaddset(&set
, target_to_host_signal(sig
));
2041 /* block signals in the handler using Linux */
2042 sigprocmask(SIG_BLOCK
, &set
, &old_set
);
2043 /* save the previous blocked signal state to restore it at the
2044 end of the signal execution (see do_sigreturn) */
2045 host_to_target_sigset_internal(&target_old_set
, &old_set
);
2047 /* if the CPU is in VM86 mode, we restore the 32 bit values */
2050 CPUX86State
*env
= cpu_env
;
2051 if (env
->eflags
& VM_MASK
)
2052 save_v86_state(env
);
2055 /* prepare the stack frame of the virtual CPU */
2056 if (k
->sa
.sa_flags
& TARGET_SA_SIGINFO
)
2057 setup_rt_frame(sig
, k
, &q
->info
, &target_old_set
, cpu_env
);
2059 setup_frame(sig
, k
, &target_old_set
, cpu_env
);
2060 if (k
->sa
.sa_flags
& TARGET_SA_RESETHAND
)
2061 k
->sa
._sa_handler
= TARGET_SIG_DFL
;