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., 51 Franklin Street - Fifth Floor, Boston,
29 #include <sys/ucontext.h>
30 #include <sys/resource.h>
33 #include "qemu-common.h"
34 #include "target_signal.h"
36 //#define DEBUG_SIGNAL
38 static struct target_sigaltstack target_sigaltstack_used
= {
41 .ss_flags
= TARGET_SS_DISABLE
,
44 static struct target_sigaction sigact_table
[TARGET_NSIG
];
46 static void host_signal_handler(int host_signum
, siginfo_t
*info
,
49 static uint8_t host_to_target_signal_table
[65] = {
50 [SIGHUP
] = TARGET_SIGHUP
,
51 [SIGINT
] = TARGET_SIGINT
,
52 [SIGQUIT
] = TARGET_SIGQUIT
,
53 [SIGILL
] = TARGET_SIGILL
,
54 [SIGTRAP
] = TARGET_SIGTRAP
,
55 [SIGABRT
] = TARGET_SIGABRT
,
56 /* [SIGIOT] = TARGET_SIGIOT,*/
57 [SIGBUS
] = TARGET_SIGBUS
,
58 [SIGFPE
] = TARGET_SIGFPE
,
59 [SIGKILL
] = TARGET_SIGKILL
,
60 [SIGUSR1
] = TARGET_SIGUSR1
,
61 [SIGSEGV
] = TARGET_SIGSEGV
,
62 [SIGUSR2
] = TARGET_SIGUSR2
,
63 [SIGPIPE
] = TARGET_SIGPIPE
,
64 [SIGALRM
] = TARGET_SIGALRM
,
65 [SIGTERM
] = TARGET_SIGTERM
,
67 [SIGSTKFLT
] = TARGET_SIGSTKFLT
,
69 [SIGCHLD
] = TARGET_SIGCHLD
,
70 [SIGCONT
] = TARGET_SIGCONT
,
71 [SIGSTOP
] = TARGET_SIGSTOP
,
72 [SIGTSTP
] = TARGET_SIGTSTP
,
73 [SIGTTIN
] = TARGET_SIGTTIN
,
74 [SIGTTOU
] = TARGET_SIGTTOU
,
75 [SIGURG
] = TARGET_SIGURG
,
76 [SIGXCPU
] = TARGET_SIGXCPU
,
77 [SIGXFSZ
] = TARGET_SIGXFSZ
,
78 [SIGVTALRM
] = TARGET_SIGVTALRM
,
79 [SIGPROF
] = TARGET_SIGPROF
,
80 [SIGWINCH
] = TARGET_SIGWINCH
,
81 [SIGIO
] = TARGET_SIGIO
,
82 [SIGPWR
] = TARGET_SIGPWR
,
83 [SIGSYS
] = TARGET_SIGSYS
,
84 /* next signals stay the same */
85 /* Nasty hack: Reverse SIGRTMIN and SIGRTMAX to avoid overlap with
86 host libpthread signals. This assumes noone actually uses SIGRTMAX :-/
87 To fix this properly we need to do manual signal delivery multiplexed
88 over a single host signal. */
89 [__SIGRTMIN
] = __SIGRTMAX
,
90 [__SIGRTMAX
] = __SIGRTMIN
,
92 static uint8_t target_to_host_signal_table
[65];
94 static inline int on_sig_stack(unsigned long sp
)
96 return (sp
- target_sigaltstack_used
.ss_sp
97 < target_sigaltstack_used
.ss_size
);
100 static inline int sas_ss_flags(unsigned long sp
)
102 return (target_sigaltstack_used
.ss_size
== 0 ? SS_DISABLE
103 : on_sig_stack(sp
) ? SS_ONSTACK
: 0);
106 int host_to_target_signal(int sig
)
110 return host_to_target_signal_table
[sig
];
113 int target_to_host_signal(int sig
)
117 return target_to_host_signal_table
[sig
];
120 static inline void target_sigemptyset(target_sigset_t
*set
)
122 memset(set
, 0, sizeof(*set
));
125 static inline void target_sigaddset(target_sigset_t
*set
, int signum
)
128 abi_ulong mask
= (abi_ulong
)1 << (signum
% TARGET_NSIG_BPW
);
129 set
->sig
[signum
/ TARGET_NSIG_BPW
] |= mask
;
132 static inline int target_sigismember(const target_sigset_t
*set
, int signum
)
135 abi_ulong mask
= (abi_ulong
)1 << (signum
% TARGET_NSIG_BPW
);
136 return ((set
->sig
[signum
/ TARGET_NSIG_BPW
] & mask
) != 0);
139 static void host_to_target_sigset_internal(target_sigset_t
*d
,
143 target_sigemptyset(d
);
144 for (i
= 1; i
<= TARGET_NSIG
; i
++) {
145 if (sigismember(s
, i
)) {
146 target_sigaddset(d
, host_to_target_signal(i
));
151 void host_to_target_sigset(target_sigset_t
*d
, const sigset_t
*s
)
156 host_to_target_sigset_internal(&d1
, s
);
157 for(i
= 0;i
< TARGET_NSIG_WORDS
; i
++)
158 d
->sig
[i
] = tswapl(d1
.sig
[i
]);
161 static void target_to_host_sigset_internal(sigset_t
*d
,
162 const target_sigset_t
*s
)
166 for (i
= 1; i
<= TARGET_NSIG
; i
++) {
167 if (target_sigismember(s
, i
)) {
168 sigaddset(d
, target_to_host_signal(i
));
173 void target_to_host_sigset(sigset_t
*d
, const target_sigset_t
*s
)
178 for(i
= 0;i
< TARGET_NSIG_WORDS
; i
++)
179 s1
.sig
[i
] = tswapl(s
->sig
[i
]);
180 target_to_host_sigset_internal(d
, &s1
);
183 void host_to_target_old_sigset(abi_ulong
*old_sigset
,
184 const sigset_t
*sigset
)
187 host_to_target_sigset(&d
, sigset
);
188 *old_sigset
= d
.sig
[0];
191 void target_to_host_old_sigset(sigset_t
*sigset
,
192 const abi_ulong
*old_sigset
)
197 d
.sig
[0] = *old_sigset
;
198 for(i
= 1;i
< TARGET_NSIG_WORDS
; i
++)
200 target_to_host_sigset(sigset
, &d
);
203 /* siginfo conversion */
205 static inline void host_to_target_siginfo_noswap(target_siginfo_t
*tinfo
,
206 const siginfo_t
*info
)
209 sig
= host_to_target_signal(info
->si_signo
);
210 tinfo
->si_signo
= sig
;
212 tinfo
->si_code
= info
->si_code
;
213 if (sig
== SIGILL
|| sig
== SIGFPE
|| sig
== SIGSEGV
||
214 sig
== SIGBUS
|| sig
== SIGTRAP
) {
215 /* should never come here, but who knows. The information for
216 the target is irrelevant */
217 tinfo
->_sifields
._sigfault
._addr
= 0;
218 } else if (sig
== SIGIO
) {
219 tinfo
->_sifields
._sigpoll
._fd
= info
->si_fd
;
220 } else if (sig
>= TARGET_SIGRTMIN
) {
221 tinfo
->_sifields
._rt
._pid
= info
->si_pid
;
222 tinfo
->_sifields
._rt
._uid
= info
->si_uid
;
223 /* XXX: potential problem if 64 bit */
224 tinfo
->_sifields
._rt
._sigval
.sival_ptr
=
225 (abi_ulong
)(unsigned long)info
->si_value
.sival_ptr
;
229 static void tswap_siginfo(target_siginfo_t
*tinfo
,
230 const target_siginfo_t
*info
)
233 sig
= info
->si_signo
;
234 tinfo
->si_signo
= tswap32(sig
);
235 tinfo
->si_errno
= tswap32(info
->si_errno
);
236 tinfo
->si_code
= tswap32(info
->si_code
);
237 if (sig
== SIGILL
|| sig
== SIGFPE
|| sig
== SIGSEGV
||
238 sig
== SIGBUS
|| sig
== SIGTRAP
) {
239 tinfo
->_sifields
._sigfault
._addr
=
240 tswapl(info
->_sifields
._sigfault
._addr
);
241 } else if (sig
== SIGIO
) {
242 tinfo
->_sifields
._sigpoll
._fd
= tswap32(info
->_sifields
._sigpoll
._fd
);
243 } else if (sig
>= TARGET_SIGRTMIN
) {
244 tinfo
->_sifields
._rt
._pid
= tswap32(info
->_sifields
._rt
._pid
);
245 tinfo
->_sifields
._rt
._uid
= tswap32(info
->_sifields
._rt
._uid
);
246 tinfo
->_sifields
._rt
._sigval
.sival_ptr
=
247 tswapl(info
->_sifields
._rt
._sigval
.sival_ptr
);
252 void host_to_target_siginfo(target_siginfo_t
*tinfo
, const siginfo_t
*info
)
254 host_to_target_siginfo_noswap(tinfo
, info
);
255 tswap_siginfo(tinfo
, tinfo
);
258 /* XXX: we support only POSIX RT signals are used. */
259 /* XXX: find a solution for 64 bit (additional malloced data is needed) */
260 void target_to_host_siginfo(siginfo_t
*info
, const target_siginfo_t
*tinfo
)
262 info
->si_signo
= tswap32(tinfo
->si_signo
);
263 info
->si_errno
= tswap32(tinfo
->si_errno
);
264 info
->si_code
= tswap32(tinfo
->si_code
);
265 info
->si_pid
= tswap32(tinfo
->_sifields
._rt
._pid
);
266 info
->si_uid
= tswap32(tinfo
->_sifields
._rt
._uid
);
267 info
->si_value
.sival_ptr
=
268 (void *)(long)tswapl(tinfo
->_sifields
._rt
._sigval
.sival_ptr
);
271 static int fatal_signal (int sig
)
276 case TARGET_SIGWINCH
:
277 /* Ignored by default. */
284 /* Job control signals. */
291 /* returns 1 if given signal should dump core if not handled */
292 static int core_dump_signal(int sig
)
308 void signal_init(void)
310 struct sigaction act
;
311 struct sigaction oact
;
315 /* generate signal conversion tables */
316 for(i
= 1; i
<= 64; i
++) {
317 if (host_to_target_signal_table
[i
] == 0)
318 host_to_target_signal_table
[i
] = i
;
320 for(i
= 1; i
<= 64; i
++) {
321 j
= host_to_target_signal_table
[i
];
322 target_to_host_signal_table
[j
] = i
;
325 /* set all host signal handlers. ALL signals are blocked during
326 the handlers to serialize them. */
327 memset(sigact_table
, 0, sizeof(sigact_table
));
329 sigfillset(&act
.sa_mask
);
330 act
.sa_flags
= SA_SIGINFO
;
331 act
.sa_sigaction
= host_signal_handler
;
332 for(i
= 1; i
<= TARGET_NSIG
; i
++) {
333 host_sig
= target_to_host_signal(i
);
334 sigaction(host_sig
, NULL
, &oact
);
335 if (oact
.sa_sigaction
== (void *)SIG_IGN
) {
336 sigact_table
[i
- 1]._sa_handler
= TARGET_SIG_IGN
;
337 } else if (oact
.sa_sigaction
== (void *)SIG_DFL
) {
338 sigact_table
[i
- 1]._sa_handler
= TARGET_SIG_DFL
;
340 /* If there's already a handler installed then something has
341 gone horribly wrong, so don't even try to handle that case. */
342 /* Install some handlers for our own use. We need at least
343 SIGSEGV and SIGBUS, to detect exceptions. We can not just
344 trap all signals because it affects syscall interrupt
345 behavior. But do trap all default-fatal signals. */
346 if (fatal_signal (i
))
347 sigaction(host_sig
, &act
, NULL
);
351 /* signal queue handling */
353 static inline struct sigqueue
*alloc_sigqueue(CPUState
*env
)
355 TaskState
*ts
= env
->opaque
;
356 struct sigqueue
*q
= ts
->first_free
;
359 ts
->first_free
= q
->next
;
363 static inline void free_sigqueue(CPUState
*env
, struct sigqueue
*q
)
365 TaskState
*ts
= env
->opaque
;
366 q
->next
= ts
->first_free
;
370 /* abort execution with signal */
371 static void QEMU_NORETURN
force_sig(int sig
)
373 TaskState
*ts
= (TaskState
*)thread_env
->opaque
;
374 int host_sig
, core_dumped
= 0;
375 struct sigaction act
;
376 host_sig
= target_to_host_signal(sig
);
377 gdb_signalled(thread_env
, sig
);
379 /* dump core if supported by target binary format */
380 if (core_dump_signal(sig
) && (ts
->bprm
->core_dump
!= NULL
)) {
383 ((*ts
->bprm
->core_dump
)(sig
, thread_env
) == 0);
386 /* we already dumped the core of target process, we don't want
387 * a coredump of qemu itself */
388 struct rlimit nodump
;
389 getrlimit(RLIMIT_CORE
, &nodump
);
391 setrlimit(RLIMIT_CORE
, &nodump
);
392 (void) fprintf(stderr
, "qemu: uncaught target signal %d (%s) - %s\n",
393 sig
, strsignal(host_sig
), "core dumped" );
396 /* The proper exit code for dieing from an uncaught signal is
397 * -<signal>. The kernel doesn't allow exit() or _exit() to pass
398 * a negative value. To get the proper exit code we need to
399 * actually die from an uncaught signal. Here the default signal
400 * handler is installed, we send ourself a signal and we wait for
402 sigfillset(&act
.sa_mask
);
403 act
.sa_handler
= SIG_DFL
;
404 sigaction(host_sig
, &act
, NULL
);
406 /* For some reason raise(host_sig) doesn't send the signal when
407 * statically linked on x86-64. */
408 kill(getpid(), host_sig
);
410 /* Make sure the signal isn't masked (just reuse the mask inside
412 sigdelset(&act
.sa_mask
, host_sig
);
413 sigsuspend(&act
.sa_mask
);
420 /* queue a signal so that it will be send to the virtual CPU as soon
422 int queue_signal(CPUState
*env
, int sig
, target_siginfo_t
*info
)
424 TaskState
*ts
= env
->opaque
;
425 struct emulated_sigtable
*k
;
426 struct sigqueue
*q
, **pq
;
430 #if defined(DEBUG_SIGNAL)
431 fprintf(stderr
, "queue_signal: sig=%d\n",
434 k
= &ts
->sigtab
[sig
- 1];
435 queue
= gdb_queuesig ();
436 handler
= sigact_table
[sig
- 1]._sa_handler
;
437 if (!queue
&& handler
== TARGET_SIG_DFL
) {
438 if (sig
== TARGET_SIGTSTP
|| sig
== TARGET_SIGTTIN
|| sig
== TARGET_SIGTTOU
) {
439 kill(getpid(),SIGSTOP
);
442 /* default handler : ignore some signal. The other are fatal */
443 if (sig
!= TARGET_SIGCHLD
&&
444 sig
!= TARGET_SIGURG
&&
445 sig
!= TARGET_SIGWINCH
&&
446 sig
!= TARGET_SIGCONT
) {
449 return 0; /* indicate ignored */
451 } else if (!queue
&& handler
== TARGET_SIG_IGN
) {
454 } else if (!queue
&& handler
== TARGET_SIG_ERR
) {
458 if (sig
< TARGET_SIGRTMIN
) {
459 /* if non real time signal, we queue exactly one signal */
469 q
= alloc_sigqueue(env
);
480 /* signal that a new signal is pending */
481 ts
->signal_pending
= 1;
482 return 1; /* indicates that the signal was queued */
486 static void host_signal_handler(int host_signum
, siginfo_t
*info
,
490 target_siginfo_t tinfo
;
492 /* the CPU emulator uses some host signals to detect exceptions,
493 we forward to it some signals */
494 if ((host_signum
== SIGSEGV
|| host_signum
== SIGBUS
)
495 && info
->si_code
> 0) {
496 if (cpu_signal_handler(host_signum
, info
, puc
))
500 /* get target signal number */
501 sig
= host_to_target_signal(host_signum
);
502 if (sig
< 1 || sig
> TARGET_NSIG
)
504 #if defined(DEBUG_SIGNAL)
505 fprintf(stderr
, "qemu: got signal %d\n", sig
);
507 host_to_target_siginfo_noswap(&tinfo
, info
);
508 if (queue_signal(thread_env
, sig
, &tinfo
) == 1) {
509 /* interrupt the virtual CPU as soon as possible */
510 cpu_exit(thread_env
);
514 /* do_sigaltstack() returns target values and errnos. */
515 /* compare linux/kernel/signal.c:do_sigaltstack() */
516 abi_long
do_sigaltstack(abi_ulong uss_addr
, abi_ulong uoss_addr
, abi_ulong sp
)
519 struct target_sigaltstack oss
;
521 /* XXX: test errors */
524 __put_user(target_sigaltstack_used
.ss_sp
, &oss
.ss_sp
);
525 __put_user(target_sigaltstack_used
.ss_size
, &oss
.ss_size
);
526 __put_user(sas_ss_flags(sp
), &oss
.ss_flags
);
531 struct target_sigaltstack
*uss
;
532 struct target_sigaltstack ss
;
534 ret
= -TARGET_EFAULT
;
535 if (!lock_user_struct(VERIFY_READ
, uss
, uss_addr
, 1)
536 || __get_user(ss
.ss_sp
, &uss
->ss_sp
)
537 || __get_user(ss
.ss_size
, &uss
->ss_size
)
538 || __get_user(ss
.ss_flags
, &uss
->ss_flags
))
540 unlock_user_struct(uss
, uss_addr
, 0);
543 if (on_sig_stack(sp
))
546 ret
= -TARGET_EINVAL
;
547 if (ss
.ss_flags
!= TARGET_SS_DISABLE
548 && ss
.ss_flags
!= TARGET_SS_ONSTACK
552 if (ss
.ss_flags
== TARGET_SS_DISABLE
) {
556 ret
= -TARGET_ENOMEM
;
557 if (ss
.ss_size
< MINSIGSTKSZ
)
561 target_sigaltstack_used
.ss_sp
= ss
.ss_sp
;
562 target_sigaltstack_used
.ss_size
= ss
.ss_size
;
566 ret
= -TARGET_EFAULT
;
567 if (copy_to_user(uoss_addr
, &oss
, sizeof(oss
)))
576 /* do_sigaction() return host values and errnos */
577 int do_sigaction(int sig
, const struct target_sigaction
*act
,
578 struct target_sigaction
*oact
)
580 struct target_sigaction
*k
;
581 struct sigaction act1
;
585 if (sig
< 1 || sig
> TARGET_NSIG
|| sig
== TARGET_SIGKILL
|| sig
== TARGET_SIGSTOP
)
587 k
= &sigact_table
[sig
- 1];
588 #if defined(DEBUG_SIGNAL)
589 fprintf(stderr
, "sigaction sig=%d act=0x%08x, oact=0x%08x\n",
590 sig
, (int)act
, (int)oact
);
593 oact
->_sa_handler
= tswapl(k
->_sa_handler
);
594 oact
->sa_flags
= tswapl(k
->sa_flags
);
595 #if !defined(TARGET_MIPS)
596 oact
->sa_restorer
= tswapl(k
->sa_restorer
);
598 oact
->sa_mask
= k
->sa_mask
;
601 /* FIXME: This is not threadsafe. */
602 k
->_sa_handler
= tswapl(act
->_sa_handler
);
603 k
->sa_flags
= tswapl(act
->sa_flags
);
604 #if !defined(TARGET_MIPS)
605 k
->sa_restorer
= tswapl(act
->sa_restorer
);
607 k
->sa_mask
= act
->sa_mask
;
609 /* we update the host linux signal state */
610 host_sig
= target_to_host_signal(sig
);
611 if (host_sig
!= SIGSEGV
&& host_sig
!= SIGBUS
) {
612 sigfillset(&act1
.sa_mask
);
613 act1
.sa_flags
= SA_SIGINFO
;
614 if (k
->sa_flags
& TARGET_SA_RESTART
)
615 act1
.sa_flags
|= SA_RESTART
;
616 /* NOTE: it is important to update the host kernel signal
617 ignore state to avoid getting unexpected interrupted
619 if (k
->_sa_handler
== TARGET_SIG_IGN
) {
620 act1
.sa_sigaction
= (void *)SIG_IGN
;
621 } else if (k
->_sa_handler
== TARGET_SIG_DFL
) {
622 if (fatal_signal (sig
))
623 act1
.sa_sigaction
= host_signal_handler
;
625 act1
.sa_sigaction
= (void *)SIG_DFL
;
627 act1
.sa_sigaction
= host_signal_handler
;
629 ret
= sigaction(host_sig
, &act1
, NULL
);
635 static inline int copy_siginfo_to_user(target_siginfo_t
*tinfo
,
636 const target_siginfo_t
*info
)
638 tswap_siginfo(tinfo
, info
);
642 static inline int current_exec_domain_sig(int sig
)
644 return /* current->exec_domain && current->exec_domain->signal_invmap
645 && sig < 32 ? current->exec_domain->signal_invmap[sig] : */ sig
;
648 #if defined(TARGET_I386) && TARGET_ABI_BITS == 32
650 /* from the Linux kernel */
652 struct target_fpreg
{
653 uint16_t significand
[4];
657 struct target_fpxreg
{
658 uint16_t significand
[4];
663 struct target_xmmreg
{
664 abi_ulong element
[4];
667 struct target_fpstate
{
668 /* Regular FPU environment */
676 struct target_fpreg _st
[8];
678 uint16_t magic
; /* 0xffff = regular FPU data only */
680 /* FXSR FPU environment */
681 abi_ulong _fxsr_env
[6]; /* FXSR FPU env is ignored */
684 struct target_fpxreg _fxsr_st
[8]; /* FXSR FPU reg data is ignored */
685 struct target_xmmreg _xmm
[8];
686 abi_ulong padding
[56];
689 #define X86_FXSR_MAGIC 0x0000
691 struct target_sigcontext
{
709 abi_ulong esp_at_signal
;
711 abi_ulong fpstate
; /* pointer */
716 struct target_ucontext
{
719 target_stack_t tuc_stack
;
720 struct target_sigcontext tuc_mcontext
;
721 target_sigset_t tuc_sigmask
; /* mask last for extensibility */
728 struct target_sigcontext sc
;
729 struct target_fpstate fpstate
;
730 abi_ulong extramask
[TARGET_NSIG_WORDS
-1];
740 struct target_siginfo info
;
741 struct target_ucontext uc
;
742 struct target_fpstate fpstate
;
747 * Set up a signal frame.
750 /* XXX: save x87 state */
752 setup_sigcontext(struct target_sigcontext
*sc
, struct target_fpstate
*fpstate
,
753 CPUX86State
*env
, abi_ulong mask
, abi_ulong fpstate_addr
)
758 /* already locked in setup_frame() */
759 err
|= __put_user(env
->segs
[R_GS
].selector
, (unsigned int *)&sc
->gs
);
760 err
|= __put_user(env
->segs
[R_FS
].selector
, (unsigned int *)&sc
->fs
);
761 err
|= __put_user(env
->segs
[R_ES
].selector
, (unsigned int *)&sc
->es
);
762 err
|= __put_user(env
->segs
[R_DS
].selector
, (unsigned int *)&sc
->ds
);
763 err
|= __put_user(env
->regs
[R_EDI
], &sc
->edi
);
764 err
|= __put_user(env
->regs
[R_ESI
], &sc
->esi
);
765 err
|= __put_user(env
->regs
[R_EBP
], &sc
->ebp
);
766 err
|= __put_user(env
->regs
[R_ESP
], &sc
->esp
);
767 err
|= __put_user(env
->regs
[R_EBX
], &sc
->ebx
);
768 err
|= __put_user(env
->regs
[R_EDX
], &sc
->edx
);
769 err
|= __put_user(env
->regs
[R_ECX
], &sc
->ecx
);
770 err
|= __put_user(env
->regs
[R_EAX
], &sc
->eax
);
771 err
|= __put_user(env
->exception_index
, &sc
->trapno
);
772 err
|= __put_user(env
->error_code
, &sc
->err
);
773 err
|= __put_user(env
->eip
, &sc
->eip
);
774 err
|= __put_user(env
->segs
[R_CS
].selector
, (unsigned int *)&sc
->cs
);
775 err
|= __put_user(env
->eflags
, &sc
->eflags
);
776 err
|= __put_user(env
->regs
[R_ESP
], &sc
->esp_at_signal
);
777 err
|= __put_user(env
->segs
[R_SS
].selector
, (unsigned int *)&sc
->ss
);
779 cpu_x86_fsave(env
, fpstate_addr
, 1);
780 fpstate
->status
= fpstate
->sw
;
782 err
|= __put_user(magic
, &fpstate
->magic
);
783 err
|= __put_user(fpstate_addr
, &sc
->fpstate
);
785 /* non-iBCS2 extensions.. */
786 err
|= __put_user(mask
, &sc
->oldmask
);
787 err
|= __put_user(env
->cr
[2], &sc
->cr2
);
792 * Determine which stack to use..
795 static inline abi_ulong
796 get_sigframe(struct target_sigaction
*ka
, CPUX86State
*env
, size_t frame_size
)
800 /* Default to using normal stack */
801 esp
= env
->regs
[R_ESP
];
802 /* This is the X/Open sanctioned signal stack switching. */
803 if (ka
->sa_flags
& TARGET_SA_ONSTACK
) {
804 if (sas_ss_flags(esp
) == 0)
805 esp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
808 /* This is the legacy signal stack switching. */
810 if ((env
->segs
[R_SS
].selector
& 0xffff) != __USER_DS
&&
811 !(ka
->sa_flags
& TARGET_SA_RESTORER
) &&
813 esp
= (unsigned long) ka
->sa_restorer
;
815 return (esp
- frame_size
) & -8ul;
818 /* compare linux/arch/i386/kernel/signal.c:setup_frame() */
819 static void setup_frame(int sig
, struct target_sigaction
*ka
,
820 target_sigset_t
*set
, CPUX86State
*env
)
822 abi_ulong frame_addr
;
823 struct sigframe
*frame
;
826 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
828 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
831 err
|= __put_user(current_exec_domain_sig(sig
),
836 setup_sigcontext(&frame
->sc
, &frame
->fpstate
, env
, set
->sig
[0],
837 frame_addr
+ offsetof(struct sigframe
, fpstate
));
841 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
842 if (__put_user(set
->sig
[i
], &frame
->extramask
[i
- 1]))
846 /* Set up to return from userspace. If provided, use a stub
847 already in userspace. */
848 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
849 err
|= __put_user(ka
->sa_restorer
, &frame
->pretcode
);
852 abi_ulong retcode_addr
;
853 retcode_addr
= frame_addr
+ offsetof(struct sigframe
, retcode
);
854 err
|= __put_user(retcode_addr
, &frame
->pretcode
);
855 /* This is popl %eax ; movl $,%eax ; int $0x80 */
857 err
|= __put_user(val16
, (uint16_t *)(frame
->retcode
+0));
858 err
|= __put_user(TARGET_NR_sigreturn
, (int *)(frame
->retcode
+2));
860 err
|= __put_user(val16
, (uint16_t *)(frame
->retcode
+6));
866 /* Set up registers for signal handler */
867 env
->regs
[R_ESP
] = frame_addr
;
868 env
->eip
= ka
->_sa_handler
;
870 cpu_x86_load_seg(env
, R_DS
, __USER_DS
);
871 cpu_x86_load_seg(env
, R_ES
, __USER_DS
);
872 cpu_x86_load_seg(env
, R_SS
, __USER_DS
);
873 cpu_x86_load_seg(env
, R_CS
, __USER_CS
);
874 env
->eflags
&= ~TF_MASK
;
876 unlock_user_struct(frame
, frame_addr
, 1);
881 unlock_user_struct(frame
, frame_addr
, 1);
882 if (sig
== TARGET_SIGSEGV
)
883 ka
->_sa_handler
= TARGET_SIG_DFL
;
884 force_sig(TARGET_SIGSEGV
/* , current */);
887 /* compare linux/arch/i386/kernel/signal.c:setup_rt_frame() */
888 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
889 target_siginfo_t
*info
,
890 target_sigset_t
*set
, CPUX86State
*env
)
892 abi_ulong frame_addr
, addr
;
893 struct rt_sigframe
*frame
;
896 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
898 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
901 err
|= __put_user(current_exec_domain_sig(sig
),
903 addr
= frame_addr
+ offsetof(struct rt_sigframe
, info
);
904 err
|= __put_user(addr
, &frame
->pinfo
);
905 addr
= frame_addr
+ offsetof(struct rt_sigframe
, uc
);
906 err
|= __put_user(addr
, &frame
->puc
);
907 err
|= copy_siginfo_to_user(&frame
->info
, info
);
911 /* Create the ucontext. */
912 err
|= __put_user(0, &frame
->uc
.tuc_flags
);
913 err
|= __put_user(0, &frame
->uc
.tuc_link
);
914 err
|= __put_user(target_sigaltstack_used
.ss_sp
,
915 &frame
->uc
.tuc_stack
.ss_sp
);
916 err
|= __put_user(sas_ss_flags(get_sp_from_cpustate(env
)),
917 &frame
->uc
.tuc_stack
.ss_flags
);
918 err
|= __put_user(target_sigaltstack_used
.ss_size
,
919 &frame
->uc
.tuc_stack
.ss_size
);
920 err
|= setup_sigcontext(&frame
->uc
.tuc_mcontext
, &frame
->fpstate
,
922 frame_addr
+ offsetof(struct rt_sigframe
, fpstate
));
923 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
924 if (__put_user(set
->sig
[i
], &frame
->uc
.tuc_sigmask
.sig
[i
]))
928 /* Set up to return from userspace. If provided, use a stub
929 already in userspace. */
930 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
931 err
|= __put_user(ka
->sa_restorer
, &frame
->pretcode
);
934 addr
= frame_addr
+ offsetof(struct rt_sigframe
, retcode
);
935 err
|= __put_user(addr
, &frame
->pretcode
);
936 /* This is movl $,%eax ; int $0x80 */
937 err
|= __put_user(0xb8, (char *)(frame
->retcode
+0));
938 err
|= __put_user(TARGET_NR_rt_sigreturn
, (int *)(frame
->retcode
+1));
940 err
|= __put_user(val16
, (uint16_t *)(frame
->retcode
+5));
946 /* Set up registers for signal handler */
947 env
->regs
[R_ESP
] = frame_addr
;
948 env
->eip
= ka
->_sa_handler
;
950 cpu_x86_load_seg(env
, R_DS
, __USER_DS
);
951 cpu_x86_load_seg(env
, R_ES
, __USER_DS
);
952 cpu_x86_load_seg(env
, R_SS
, __USER_DS
);
953 cpu_x86_load_seg(env
, R_CS
, __USER_CS
);
954 env
->eflags
&= ~TF_MASK
;
956 unlock_user_struct(frame
, frame_addr
, 1);
961 unlock_user_struct(frame
, frame_addr
, 1);
962 if (sig
== TARGET_SIGSEGV
)
963 ka
->_sa_handler
= TARGET_SIG_DFL
;
964 force_sig(TARGET_SIGSEGV
/* , current */);
968 restore_sigcontext(CPUX86State
*env
, struct target_sigcontext
*sc
, int *peax
)
970 unsigned int err
= 0;
971 abi_ulong fpstate_addr
;
972 unsigned int tmpflags
;
974 cpu_x86_load_seg(env
, R_GS
, tswap16(sc
->gs
));
975 cpu_x86_load_seg(env
, R_FS
, tswap16(sc
->fs
));
976 cpu_x86_load_seg(env
, R_ES
, tswap16(sc
->es
));
977 cpu_x86_load_seg(env
, R_DS
, tswap16(sc
->ds
));
979 env
->regs
[R_EDI
] = tswapl(sc
->edi
);
980 env
->regs
[R_ESI
] = tswapl(sc
->esi
);
981 env
->regs
[R_EBP
] = tswapl(sc
->ebp
);
982 env
->regs
[R_ESP
] = tswapl(sc
->esp
);
983 env
->regs
[R_EBX
] = tswapl(sc
->ebx
);
984 env
->regs
[R_EDX
] = tswapl(sc
->edx
);
985 env
->regs
[R_ECX
] = tswapl(sc
->ecx
);
986 env
->eip
= tswapl(sc
->eip
);
988 cpu_x86_load_seg(env
, R_CS
, lduw(&sc
->cs
) | 3);
989 cpu_x86_load_seg(env
, R_SS
, lduw(&sc
->ss
) | 3);
991 tmpflags
= tswapl(sc
->eflags
);
992 env
->eflags
= (env
->eflags
& ~0x40DD5) | (tmpflags
& 0x40DD5);
993 // regs->orig_eax = -1; /* disable syscall checks */
995 fpstate_addr
= tswapl(sc
->fpstate
);
996 if (fpstate_addr
!= 0) {
997 if (!access_ok(VERIFY_READ
, fpstate_addr
,
998 sizeof(struct target_fpstate
)))
1000 cpu_x86_frstor(env
, fpstate_addr
, 1);
1003 *peax
= tswapl(sc
->eax
);
1009 long do_sigreturn(CPUX86State
*env
)
1011 struct sigframe
*frame
;
1012 abi_ulong frame_addr
= env
->regs
[R_ESP
] - 8;
1013 target_sigset_t target_set
;
1017 #if defined(DEBUG_SIGNAL)
1018 fprintf(stderr
, "do_sigreturn\n");
1020 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
1022 /* set blocked signals */
1023 if (__get_user(target_set
.sig
[0], &frame
->sc
.oldmask
))
1025 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
1026 if (__get_user(target_set
.sig
[i
], &frame
->extramask
[i
- 1]))
1030 target_to_host_sigset_internal(&set
, &target_set
);
1031 sigprocmask(SIG_SETMASK
, &set
, NULL
);
1033 /* restore registers */
1034 if (restore_sigcontext(env
, &frame
->sc
, &eax
))
1036 unlock_user_struct(frame
, frame_addr
, 0);
1040 unlock_user_struct(frame
, frame_addr
, 0);
1041 force_sig(TARGET_SIGSEGV
);
1045 long do_rt_sigreturn(CPUX86State
*env
)
1047 abi_ulong frame_addr
;
1048 struct rt_sigframe
*frame
;
1052 frame_addr
= env
->regs
[R_ESP
] - 4;
1053 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
1055 target_to_host_sigset(&set
, &frame
->uc
.tuc_sigmask
);
1056 sigprocmask(SIG_SETMASK
, &set
, NULL
);
1058 if (restore_sigcontext(env
, &frame
->uc
.tuc_mcontext
, &eax
))
1061 if (do_sigaltstack(frame_addr
+ offsetof(struct rt_sigframe
, uc
.tuc_stack
), 0,
1062 get_sp_from_cpustate(env
)) == -EFAULT
)
1065 unlock_user_struct(frame
, frame_addr
, 0);
1069 unlock_user_struct(frame
, frame_addr
, 0);
1070 force_sig(TARGET_SIGSEGV
);
1074 #elif defined(TARGET_ARM)
1076 struct target_sigcontext
{
1078 abi_ulong error_code
;
1097 abi_ulong fault_address
;
1100 struct target_ucontext_v1
{
1101 abi_ulong tuc_flags
;
1103 target_stack_t tuc_stack
;
1104 struct target_sigcontext tuc_mcontext
;
1105 target_sigset_t tuc_sigmask
; /* mask last for extensibility */
1108 struct target_ucontext_v2
{
1109 abi_ulong tuc_flags
;
1111 target_stack_t tuc_stack
;
1112 struct target_sigcontext tuc_mcontext
;
1113 target_sigset_t tuc_sigmask
; /* mask last for extensibility */
1114 char __unused
[128 - sizeof(sigset_t
)];
1115 abi_ulong tuc_regspace
[128] __attribute__((__aligned__(8)));
1120 struct target_sigcontext sc
;
1121 abi_ulong extramask
[TARGET_NSIG_WORDS
-1];
1127 struct target_ucontext_v2 uc
;
1131 struct rt_sigframe_v1
1135 struct target_siginfo info
;
1136 struct target_ucontext_v1 uc
;
1140 struct rt_sigframe_v2
1142 struct target_siginfo info
;
1143 struct target_ucontext_v2 uc
;
1147 #define TARGET_CONFIG_CPU_32 1
1150 * For ARM syscalls, we encode the syscall number into the instruction.
1152 #define SWI_SYS_SIGRETURN (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
1153 #define SWI_SYS_RT_SIGRETURN (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
1156 * For Thumb syscalls, we pass the syscall number via r7. We therefore
1157 * need two 16-bit instructions.
1159 #define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
1160 #define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
1162 static const abi_ulong retcodes
[4] = {
1163 SWI_SYS_SIGRETURN
, SWI_THUMB_SIGRETURN
,
1164 SWI_SYS_RT_SIGRETURN
, SWI_THUMB_RT_SIGRETURN
1168 #define __get_user_error(x,p,e) __get_user(x, p)
1170 static inline int valid_user_regs(CPUState
*regs
)
1176 setup_sigcontext(struct target_sigcontext
*sc
, /*struct _fpstate *fpstate,*/
1177 CPUState
*env
, abi_ulong mask
)
1179 __put_user(env
->regs
[0], &sc
->arm_r0
);
1180 __put_user(env
->regs
[1], &sc
->arm_r1
);
1181 __put_user(env
->regs
[2], &sc
->arm_r2
);
1182 __put_user(env
->regs
[3], &sc
->arm_r3
);
1183 __put_user(env
->regs
[4], &sc
->arm_r4
);
1184 __put_user(env
->regs
[5], &sc
->arm_r5
);
1185 __put_user(env
->regs
[6], &sc
->arm_r6
);
1186 __put_user(env
->regs
[7], &sc
->arm_r7
);
1187 __put_user(env
->regs
[8], &sc
->arm_r8
);
1188 __put_user(env
->regs
[9], &sc
->arm_r9
);
1189 __put_user(env
->regs
[10], &sc
->arm_r10
);
1190 __put_user(env
->regs
[11], &sc
->arm_fp
);
1191 __put_user(env
->regs
[12], &sc
->arm_ip
);
1192 __put_user(env
->regs
[13], &sc
->arm_sp
);
1193 __put_user(env
->regs
[14], &sc
->arm_lr
);
1194 __put_user(env
->regs
[15], &sc
->arm_pc
);
1195 #ifdef TARGET_CONFIG_CPU_32
1196 __put_user(cpsr_read(env
), &sc
->arm_cpsr
);
1199 __put_user(/* current->thread.trap_no */ 0, &sc
->trap_no
);
1200 __put_user(/* current->thread.error_code */ 0, &sc
->error_code
);
1201 __put_user(/* current->thread.address */ 0, &sc
->fault_address
);
1202 __put_user(mask
, &sc
->oldmask
);
1205 static inline abi_ulong
1206 get_sigframe(struct target_sigaction
*ka
, CPUState
*regs
, int framesize
)
1208 unsigned long sp
= regs
->regs
[13];
1211 * This is the X/Open sanctioned signal stack switching.
1213 if ((ka
->sa_flags
& TARGET_SA_ONSTACK
) && !sas_ss_flags(sp
))
1214 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
1216 * ATPCS B01 mandates 8-byte alignment
1218 return (sp
- framesize
) & ~7;
1222 setup_return(CPUState
*env
, struct target_sigaction
*ka
,
1223 abi_ulong
*rc
, abi_ulong frame_addr
, int usig
, abi_ulong rc_addr
)
1225 abi_ulong handler
= ka
->_sa_handler
;
1227 int thumb
= handler
& 1;
1229 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
1230 retcode
= ka
->sa_restorer
;
1232 unsigned int idx
= thumb
;
1234 if (ka
->sa_flags
& TARGET_SA_SIGINFO
)
1237 if (__put_user(retcodes
[idx
], rc
))
1240 flush_icache_range((abi_ulong
)rc
,
1241 (abi_ulong
)(rc
+ 1));
1243 retcode
= rc_addr
+ thumb
;
1246 env
->regs
[0] = usig
;
1247 env
->regs
[13] = frame_addr
;
1248 env
->regs
[14] = retcode
;
1249 env
->regs
[15] = handler
& (thumb
? ~1 : ~3);
1253 #ifdef TARGET_CONFIG_CPU_32
1261 static void setup_sigframe_v2(struct target_ucontext_v2
*uc
,
1262 target_sigset_t
*set
, CPUState
*env
)
1264 struct target_sigaltstack stack
;
1267 /* Clear all the bits of the ucontext we don't use. */
1268 memset(uc
, 0, offsetof(struct target_ucontext_v2
, tuc_mcontext
));
1270 memset(&stack
, 0, sizeof(stack
));
1271 __put_user(target_sigaltstack_used
.ss_sp
, &stack
.ss_sp
);
1272 __put_user(target_sigaltstack_used
.ss_size
, &stack
.ss_size
);
1273 __put_user(sas_ss_flags(get_sp_from_cpustate(env
)), &stack
.ss_flags
);
1274 memcpy(&uc
->tuc_stack
, &stack
, sizeof(stack
));
1276 setup_sigcontext(&uc
->tuc_mcontext
, env
, set
->sig
[0]);
1277 /* FIXME: Save coprocessor signal frame. */
1278 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
1279 __put_user(set
->sig
[i
], &uc
->tuc_sigmask
.sig
[i
]);
1283 /* compare linux/arch/arm/kernel/signal.c:setup_frame() */
1284 static void setup_frame_v1(int usig
, struct target_sigaction
*ka
,
1285 target_sigset_t
*set
, CPUState
*regs
)
1287 struct sigframe_v1
*frame
;
1288 abi_ulong frame_addr
= get_sigframe(ka
, regs
, sizeof(*frame
));
1291 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
1294 setup_sigcontext(&frame
->sc
, regs
, set
->sig
[0]);
1296 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
1297 if (__put_user(set
->sig
[i
], &frame
->extramask
[i
- 1]))
1301 setup_return(regs
, ka
, &frame
->retcode
, frame_addr
, usig
,
1302 frame_addr
+ offsetof(struct sigframe_v1
, retcode
));
1305 unlock_user_struct(frame
, frame_addr
, 1);
1308 static void setup_frame_v2(int usig
, struct target_sigaction
*ka
,
1309 target_sigset_t
*set
, CPUState
*regs
)
1311 struct sigframe_v2
*frame
;
1312 abi_ulong frame_addr
= get_sigframe(ka
, regs
, sizeof(*frame
));
1314 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
1317 setup_sigframe_v2(&frame
->uc
, set
, regs
);
1319 setup_return(regs
, ka
, &frame
->retcode
, frame_addr
, usig
,
1320 frame_addr
+ offsetof(struct sigframe_v2
, retcode
));
1322 unlock_user_struct(frame
, frame_addr
, 1);
1325 static void setup_frame(int usig
, struct target_sigaction
*ka
,
1326 target_sigset_t
*set
, CPUState
*regs
)
1328 if (get_osversion() >= 0x020612) {
1329 setup_frame_v2(usig
, ka
, set
, regs
);
1331 setup_frame_v1(usig
, ka
, set
, regs
);
1335 /* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */
1336 static void setup_rt_frame_v1(int usig
, struct target_sigaction
*ka
,
1337 target_siginfo_t
*info
,
1338 target_sigset_t
*set
, CPUState
*env
)
1340 struct rt_sigframe_v1
*frame
;
1341 abi_ulong frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
1342 struct target_sigaltstack stack
;
1344 abi_ulong info_addr
, uc_addr
;
1346 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
1349 info_addr
= frame_addr
+ offsetof(struct rt_sigframe_v1
, info
);
1350 __put_user(info_addr
, &frame
->pinfo
);
1351 uc_addr
= frame_addr
+ offsetof(struct rt_sigframe_v1
, uc
);
1352 __put_user(uc_addr
, &frame
->puc
);
1353 copy_siginfo_to_user(&frame
->info
, info
);
1355 /* Clear all the bits of the ucontext we don't use. */
1356 memset(&frame
->uc
, 0, offsetof(struct target_ucontext_v1
, tuc_mcontext
));
1358 memset(&stack
, 0, sizeof(stack
));
1359 __put_user(target_sigaltstack_used
.ss_sp
, &stack
.ss_sp
);
1360 __put_user(target_sigaltstack_used
.ss_size
, &stack
.ss_size
);
1361 __put_user(sas_ss_flags(get_sp_from_cpustate(env
)), &stack
.ss_flags
);
1362 memcpy(&frame
->uc
.tuc_stack
, &stack
, sizeof(stack
));
1364 setup_sigcontext(&frame
->uc
.tuc_mcontext
, env
, set
->sig
[0]);
1365 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
1366 if (__put_user(set
->sig
[i
], &frame
->uc
.tuc_sigmask
.sig
[i
]))
1370 setup_return(env
, ka
, &frame
->retcode
, frame_addr
, usig
,
1371 frame_addr
+ offsetof(struct rt_sigframe_v1
, retcode
));
1373 env
->regs
[1] = info_addr
;
1374 env
->regs
[2] = uc_addr
;
1377 unlock_user_struct(frame
, frame_addr
, 1);
1380 static void setup_rt_frame_v2(int usig
, struct target_sigaction
*ka
,
1381 target_siginfo_t
*info
,
1382 target_sigset_t
*set
, CPUState
*env
)
1384 struct rt_sigframe_v2
*frame
;
1385 abi_ulong frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
1386 abi_ulong info_addr
, uc_addr
;
1388 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
1391 info_addr
= frame_addr
+ offsetof(struct rt_sigframe_v2
, info
);
1392 uc_addr
= frame_addr
+ offsetof(struct rt_sigframe_v2
, uc
);
1393 copy_siginfo_to_user(&frame
->info
, info
);
1395 setup_sigframe_v2(&frame
->uc
, set
, env
);
1397 setup_return(env
, ka
, &frame
->retcode
, frame_addr
, usig
,
1398 frame_addr
+ offsetof(struct rt_sigframe_v2
, retcode
));
1400 env
->regs
[1] = info_addr
;
1401 env
->regs
[2] = uc_addr
;
1403 unlock_user_struct(frame
, frame_addr
, 1);
1406 static void setup_rt_frame(int usig
, struct target_sigaction
*ka
,
1407 target_siginfo_t
*info
,
1408 target_sigset_t
*set
, CPUState
*env
)
1410 if (get_osversion() >= 0x020612) {
1411 setup_rt_frame_v2(usig
, ka
, info
, set
, env
);
1413 setup_rt_frame_v1(usig
, ka
, info
, set
, env
);
1418 restore_sigcontext(CPUState
*env
, struct target_sigcontext
*sc
)
1423 __get_user_error(env
->regs
[0], &sc
->arm_r0
, err
);
1424 __get_user_error(env
->regs
[1], &sc
->arm_r1
, err
);
1425 __get_user_error(env
->regs
[2], &sc
->arm_r2
, err
);
1426 __get_user_error(env
->regs
[3], &sc
->arm_r3
, err
);
1427 __get_user_error(env
->regs
[4], &sc
->arm_r4
, err
);
1428 __get_user_error(env
->regs
[5], &sc
->arm_r5
, err
);
1429 __get_user_error(env
->regs
[6], &sc
->arm_r6
, err
);
1430 __get_user_error(env
->regs
[7], &sc
->arm_r7
, err
);
1431 __get_user_error(env
->regs
[8], &sc
->arm_r8
, err
);
1432 __get_user_error(env
->regs
[9], &sc
->arm_r9
, err
);
1433 __get_user_error(env
->regs
[10], &sc
->arm_r10
, err
);
1434 __get_user_error(env
->regs
[11], &sc
->arm_fp
, err
);
1435 __get_user_error(env
->regs
[12], &sc
->arm_ip
, err
);
1436 __get_user_error(env
->regs
[13], &sc
->arm_sp
, err
);
1437 __get_user_error(env
->regs
[14], &sc
->arm_lr
, err
);
1438 __get_user_error(env
->regs
[15], &sc
->arm_pc
, err
);
1439 #ifdef TARGET_CONFIG_CPU_32
1440 __get_user_error(cpsr
, &sc
->arm_cpsr
, err
);
1441 cpsr_write(env
, cpsr
, CPSR_USER
| CPSR_EXEC
);
1444 err
|= !valid_user_regs(env
);
1449 static long do_sigreturn_v1(CPUState
*env
)
1451 abi_ulong frame_addr
;
1452 struct sigframe_v1
*frame
;
1453 target_sigset_t set
;
1458 * Since we stacked the signal on a 64-bit boundary,
1459 * then 'sp' should be word aligned here. If it's
1460 * not, then the user is trying to mess with us.
1462 if (env
->regs
[13] & 7)
1465 frame_addr
= env
->regs
[13];
1466 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
1469 if (__get_user(set
.sig
[0], &frame
->sc
.oldmask
))
1471 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
1472 if (__get_user(set
.sig
[i
], &frame
->extramask
[i
- 1]))
1476 target_to_host_sigset_internal(&host_set
, &set
);
1477 sigprocmask(SIG_SETMASK
, &host_set
, NULL
);
1479 if (restore_sigcontext(env
, &frame
->sc
))
1483 /* Send SIGTRAP if we're single-stepping */
1484 if (ptrace_cancel_bpt(current
))
1485 send_sig(SIGTRAP
, current
, 1);
1487 unlock_user_struct(frame
, frame_addr
, 0);
1488 return env
->regs
[0];
1491 unlock_user_struct(frame
, frame_addr
, 0);
1492 force_sig(SIGSEGV
/* , current */);
1496 static int do_sigframe_return_v2(CPUState
*env
, target_ulong frame_addr
,
1497 struct target_ucontext_v2
*uc
)
1501 target_to_host_sigset(&host_set
, &uc
->tuc_sigmask
);
1502 sigprocmask(SIG_SETMASK
, &host_set
, NULL
);
1504 if (restore_sigcontext(env
, &uc
->tuc_mcontext
))
1507 if (do_sigaltstack(frame_addr
+ offsetof(struct target_ucontext_v2
, tuc_stack
), 0, get_sp_from_cpustate(env
)) == -EFAULT
)
1511 /* Send SIGTRAP if we're single-stepping */
1512 if (ptrace_cancel_bpt(current
))
1513 send_sig(SIGTRAP
, current
, 1);
1519 static long do_sigreturn_v2(CPUState
*env
)
1521 abi_ulong frame_addr
;
1522 struct sigframe_v2
*frame
;
1525 * Since we stacked the signal on a 64-bit boundary,
1526 * then 'sp' should be word aligned here. If it's
1527 * not, then the user is trying to mess with us.
1529 if (env
->regs
[13] & 7)
1532 frame_addr
= env
->regs
[13];
1533 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
1536 if (do_sigframe_return_v2(env
, frame_addr
, &frame
->uc
))
1539 unlock_user_struct(frame
, frame_addr
, 0);
1540 return env
->regs
[0];
1543 unlock_user_struct(frame
, frame_addr
, 0);
1544 force_sig(SIGSEGV
/* , current */);
1548 long do_sigreturn(CPUState
*env
)
1550 if (get_osversion() >= 0x020612) {
1551 return do_sigreturn_v2(env
);
1553 return do_sigreturn_v1(env
);
1557 static long do_rt_sigreturn_v1(CPUState
*env
)
1559 abi_ulong frame_addr
;
1560 struct rt_sigframe_v1
*frame
;
1564 * Since we stacked the signal on a 64-bit boundary,
1565 * then 'sp' should be word aligned here. If it's
1566 * not, then the user is trying to mess with us.
1568 if (env
->regs
[13] & 7)
1571 frame_addr
= env
->regs
[13];
1572 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
1575 target_to_host_sigset(&host_set
, &frame
->uc
.tuc_sigmask
);
1576 sigprocmask(SIG_SETMASK
, &host_set
, NULL
);
1578 if (restore_sigcontext(env
, &frame
->uc
.tuc_mcontext
))
1581 if (do_sigaltstack(frame_addr
+ offsetof(struct rt_sigframe_v1
, uc
.tuc_stack
), 0, get_sp_from_cpustate(env
)) == -EFAULT
)
1585 /* Send SIGTRAP if we're single-stepping */
1586 if (ptrace_cancel_bpt(current
))
1587 send_sig(SIGTRAP
, current
, 1);
1589 unlock_user_struct(frame
, frame_addr
, 0);
1590 return env
->regs
[0];
1593 unlock_user_struct(frame
, frame_addr
, 0);
1594 force_sig(SIGSEGV
/* , current */);
1598 static long do_rt_sigreturn_v2(CPUState
*env
)
1600 abi_ulong frame_addr
;
1601 struct rt_sigframe_v2
*frame
;
1604 * Since we stacked the signal on a 64-bit boundary,
1605 * then 'sp' should be word aligned here. If it's
1606 * not, then the user is trying to mess with us.
1608 if (env
->regs
[13] & 7)
1611 frame_addr
= env
->regs
[13];
1612 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
1615 if (do_sigframe_return_v2(env
, frame_addr
, &frame
->uc
))
1618 unlock_user_struct(frame
, frame_addr
, 0);
1619 return env
->regs
[0];
1622 unlock_user_struct(frame
, frame_addr
, 0);
1623 force_sig(SIGSEGV
/* , current */);
1627 long do_rt_sigreturn(CPUState
*env
)
1629 if (get_osversion() >= 0x020612) {
1630 return do_rt_sigreturn_v2(env
);
1632 return do_rt_sigreturn_v1(env
);
1636 #elif defined(TARGET_SPARC)
1638 #define __SUNOS_MAXWIN 31
1640 /* This is what SunOS does, so shall I. */
1641 struct target_sigcontext
{
1642 abi_ulong sigc_onstack
; /* state to restore */
1644 abi_ulong sigc_mask
; /* sigmask to restore */
1645 abi_ulong sigc_sp
; /* stack pointer */
1646 abi_ulong sigc_pc
; /* program counter */
1647 abi_ulong sigc_npc
; /* next program counter */
1648 abi_ulong sigc_psr
; /* for condition codes etc */
1649 abi_ulong sigc_g1
; /* User uses these two registers */
1650 abi_ulong sigc_o0
; /* within the trampoline code. */
1652 /* Now comes information regarding the users window set
1653 * at the time of the signal.
1655 abi_ulong sigc_oswins
; /* outstanding windows */
1657 /* stack ptrs for each regwin buf */
1658 char *sigc_spbuf
[__SUNOS_MAXWIN
];
1660 /* Windows to restore after signal */
1662 abi_ulong locals
[8];
1664 } sigc_wbuf
[__SUNOS_MAXWIN
];
1666 /* A Sparc stack frame */
1667 struct sparc_stackf
{
1668 abi_ulong locals
[8];
1670 struct sparc_stackf
*fp
;
1671 abi_ulong callers_pc
;
1674 abi_ulong xxargs
[1];
1683 abi_ulong u_regs
[16]; /* globals and ins */
1689 unsigned long si_float_regs
[32];
1690 unsigned long si_fsr
;
1691 unsigned long si_fpqdepth
;
1693 unsigned long *insn_addr
;
1696 } qemu_siginfo_fpu_t
;
1699 struct target_signal_frame
{
1700 struct sparc_stackf ss
;
1703 abi_ulong insns
[2] __attribute__ ((aligned (8)));
1704 abi_ulong extramask
[TARGET_NSIG_WORDS
- 1];
1705 abi_ulong extra_size
; /* Should be 0 */
1706 qemu_siginfo_fpu_t fpu_state
;
1708 struct target_rt_signal_frame
{
1709 struct sparc_stackf ss
;
1714 unsigned int insns
[2];
1716 unsigned int extra_size
; /* Should be 0 */
1717 qemu_siginfo_fpu_t fpu_state
;
1731 #define UREG_FP UREG_I6
1732 #define UREG_SP UREG_O6
1734 static inline abi_ulong
get_sigframe(struct target_sigaction
*sa
,
1735 CPUState
*env
, unsigned long framesize
)
1739 sp
= env
->regwptr
[UREG_FP
];
1741 /* This is the X/Open sanctioned signal stack switching. */
1742 if (sa
->sa_flags
& TARGET_SA_ONSTACK
) {
1743 if (!on_sig_stack(sp
)
1744 && !((target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
) & 7))
1745 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
1747 return sp
- framesize
;
1751 setup___siginfo(__siginfo_t
*si
, CPUState
*env
, abi_ulong mask
)
1755 err
|= __put_user(env
->psr
, &si
->si_regs
.psr
);
1756 err
|= __put_user(env
->pc
, &si
->si_regs
.pc
);
1757 err
|= __put_user(env
->npc
, &si
->si_regs
.npc
);
1758 err
|= __put_user(env
->y
, &si
->si_regs
.y
);
1759 for (i
=0; i
< 8; i
++) {
1760 err
|= __put_user(env
->gregs
[i
], &si
->si_regs
.u_regs
[i
]);
1762 for (i
=0; i
< 8; i
++) {
1763 err
|= __put_user(env
->regwptr
[UREG_I0
+ i
], &si
->si_regs
.u_regs
[i
+8]);
1765 err
|= __put_user(mask
, &si
->si_mask
);
1771 setup_sigcontext(struct target_sigcontext
*sc
, /*struct _fpstate *fpstate,*/
1772 CPUState
*env
, unsigned long mask
)
1776 err
|= __put_user(mask
, &sc
->sigc_mask
);
1777 err
|= __put_user(env
->regwptr
[UREG_SP
], &sc
->sigc_sp
);
1778 err
|= __put_user(env
->pc
, &sc
->sigc_pc
);
1779 err
|= __put_user(env
->npc
, &sc
->sigc_npc
);
1780 err
|= __put_user(env
->psr
, &sc
->sigc_psr
);
1781 err
|= __put_user(env
->gregs
[1], &sc
->sigc_g1
);
1782 err
|= __put_user(env
->regwptr
[UREG_O0
], &sc
->sigc_o0
);
1787 #define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7)))
1789 static void setup_frame(int sig
, struct target_sigaction
*ka
,
1790 target_sigset_t
*set
, CPUState
*env
)
1793 struct target_signal_frame
*sf
;
1794 int sigframe_size
, err
, i
;
1796 /* 1. Make sure everything is clean */
1797 //synchronize_user_stack();
1799 sigframe_size
= NF_ALIGNEDSZ
;
1800 sf_addr
= get_sigframe(ka
, env
, sigframe_size
);
1802 sf
= lock_user(VERIFY_WRITE
, sf_addr
,
1803 sizeof(struct target_signal_frame
), 0);
1807 //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1809 if (invalid_frame_pointer(sf
, sigframe_size
))
1810 goto sigill_and_return
;
1812 /* 2. Save the current process state */
1813 err
= setup___siginfo(&sf
->info
, env
, set
->sig
[0]);
1814 err
|= __put_user(0, &sf
->extra_size
);
1816 //err |= save_fpu_state(regs, &sf->fpu_state);
1817 //err |= __put_user(&sf->fpu_state, &sf->fpu_save);
1819 err
|= __put_user(set
->sig
[0], &sf
->info
.si_mask
);
1820 for (i
= 0; i
< TARGET_NSIG_WORDS
- 1; i
++) {
1821 err
|= __put_user(set
->sig
[i
+ 1], &sf
->extramask
[i
]);
1824 for (i
= 0; i
< 8; i
++) {
1825 err
|= __put_user(env
->regwptr
[i
+ UREG_L0
], &sf
->ss
.locals
[i
]);
1827 for (i
= 0; i
< 8; i
++) {
1828 err
|= __put_user(env
->regwptr
[i
+ UREG_I0
], &sf
->ss
.ins
[i
]);
1833 /* 3. signal handler back-trampoline and parameters */
1834 env
->regwptr
[UREG_FP
] = sf_addr
;
1835 env
->regwptr
[UREG_I0
] = sig
;
1836 env
->regwptr
[UREG_I1
] = sf_addr
+
1837 offsetof(struct target_signal_frame
, info
);
1838 env
->regwptr
[UREG_I2
] = sf_addr
+
1839 offsetof(struct target_signal_frame
, info
);
1841 /* 4. signal handler */
1842 env
->pc
= ka
->_sa_handler
;
1843 env
->npc
= (env
->pc
+ 4);
1844 /* 5. return to kernel instructions */
1845 if (ka
->sa_restorer
)
1846 env
->regwptr
[UREG_I7
] = ka
->sa_restorer
;
1850 env
->regwptr
[UREG_I7
] = sf_addr
+
1851 offsetof(struct target_signal_frame
, insns
) - 2 * 4;
1853 /* mov __NR_sigreturn, %g1 */
1855 err
|= __put_user(val32
, &sf
->insns
[0]);
1859 err
|= __put_user(val32
, &sf
->insns
[1]);
1863 /* Flush instruction space. */
1864 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
1867 unlock_user(sf
, sf_addr
, sizeof(struct target_signal_frame
));
1871 force_sig(TARGET_SIGILL
);
1874 //fprintf(stderr, "force_sig\n");
1875 unlock_user(sf
, sf_addr
, sizeof(struct target_signal_frame
));
1876 force_sig(TARGET_SIGSEGV
);
1879 restore_fpu_state(CPUState
*env
, qemu_siginfo_fpu_t
*fpu
)
1884 if (current
->flags
& PF_USEDFPU
)
1885 regs
->psr
&= ~PSR_EF
;
1887 if (current
== last_task_used_math
) {
1888 last_task_used_math
= 0;
1889 regs
->psr
&= ~PSR_EF
;
1892 current
->used_math
= 1;
1893 current
->flags
&= ~PF_USEDFPU
;
1896 if (verify_area (VERIFY_READ
, fpu
, sizeof(*fpu
)))
1901 /* XXX: incorrect */
1902 err
= __copy_from_user(&env
->fpr
[0], &fpu
->si_float_regs
[0],
1903 (sizeof(unsigned long) * 32));
1905 err
|= __get_user(env
->fsr
, &fpu
->si_fsr
);
1907 err
|= __get_user(current
->thread
.fpqdepth
, &fpu
->si_fpqdepth
);
1908 if (current
->thread
.fpqdepth
!= 0)
1909 err
|= __copy_from_user(¤t
->thread
.fpqueue
[0],
1910 &fpu
->si_fpqueue
[0],
1911 ((sizeof(unsigned long) +
1912 (sizeof(unsigned long *)))*16));
1918 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
1919 target_siginfo_t
*info
,
1920 target_sigset_t
*set
, CPUState
*env
)
1922 fprintf(stderr
, "setup_rt_frame: not implemented\n");
1925 long do_sigreturn(CPUState
*env
)
1928 struct target_signal_frame
*sf
;
1929 uint32_t up_psr
, pc
, npc
;
1930 target_sigset_t set
;
1932 abi_ulong fpu_save_addr
;
1935 sf_addr
= env
->regwptr
[UREG_FP
];
1936 if (!lock_user_struct(VERIFY_READ
, sf
, sf_addr
, 1))
1939 fprintf(stderr
, "sigreturn\n");
1940 fprintf(stderr
, "sf: %x pc %x fp %x sp %x\n", sf
, env
->pc
, env
->regwptr
[UREG_FP
], env
->regwptr
[UREG_SP
]);
1942 //cpu_dump_state(env, stderr, fprintf, 0);
1944 /* 1. Make sure we are not getting garbage from the user */
1949 err
= __get_user(pc
, &sf
->info
.si_regs
.pc
);
1950 err
|= __get_user(npc
, &sf
->info
.si_regs
.npc
);
1955 /* 2. Restore the state */
1956 err
|= __get_user(up_psr
, &sf
->info
.si_regs
.psr
);
1958 /* User can only change condition codes and FPU enabling in %psr. */
1959 env
->psr
= (up_psr
& (PSR_ICC
/* | PSR_EF */))
1960 | (env
->psr
& ~(PSR_ICC
/* | PSR_EF */));
1964 err
|= __get_user(env
->y
, &sf
->info
.si_regs
.y
);
1965 for (i
=0; i
< 8; i
++) {
1966 err
|= __get_user(env
->gregs
[i
], &sf
->info
.si_regs
.u_regs
[i
]);
1968 for (i
=0; i
< 8; i
++) {
1969 err
|= __get_user(env
->regwptr
[i
+ UREG_I0
], &sf
->info
.si_regs
.u_regs
[i
+8]);
1972 err
|= __get_user(fpu_save_addr
, &sf
->fpu_save
);
1975 // err |= restore_fpu_state(env, fpu_save);
1977 /* This is pretty much atomic, no amount locking would prevent
1978 * the races which exist anyways.
1980 err
|= __get_user(set
.sig
[0], &sf
->info
.si_mask
);
1981 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
1982 err
|= (__get_user(set
.sig
[i
], &sf
->extramask
[i
- 1]));
1985 target_to_host_sigset_internal(&host_set
, &set
);
1986 sigprocmask(SIG_SETMASK
, &host_set
, NULL
);
1990 unlock_user_struct(sf
, sf_addr
, 0);
1991 return env
->regwptr
[0];
1994 unlock_user_struct(sf
, sf_addr
, 0);
1995 force_sig(TARGET_SIGSEGV
);
1998 long do_rt_sigreturn(CPUState
*env
)
2000 fprintf(stderr
, "do_rt_sigreturn: not implemented\n");
2001 return -TARGET_ENOSYS
;
2004 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
2026 typedef abi_ulong target_mc_greg_t
;
2027 typedef target_mc_greg_t target_mc_gregset_t
[MC_NGREG
];
2029 struct target_mc_fq
{
2030 abi_ulong
*mcfq_addr
;
2034 struct target_mc_fpu
{
2038 //uint128_t qregs[16];
2040 abi_ulong mcfpu_fsr
;
2041 abi_ulong mcfpu_fprs
;
2042 abi_ulong mcfpu_gsr
;
2043 struct target_mc_fq
*mcfpu_fq
;
2044 unsigned char mcfpu_qcnt
;
2045 unsigned char mcfpu_qentsz
;
2046 unsigned char mcfpu_enab
;
2048 typedef struct target_mc_fpu target_mc_fpu_t
;
2051 target_mc_gregset_t mc_gregs
;
2052 target_mc_greg_t mc_fp
;
2053 target_mc_greg_t mc_i7
;
2054 target_mc_fpu_t mc_fpregs
;
2055 } target_mcontext_t
;
2057 struct target_ucontext
{
2058 struct target_ucontext
*uc_link
;
2060 target_sigset_t uc_sigmask
;
2061 target_mcontext_t uc_mcontext
;
2064 /* A V9 register window */
2065 struct target_reg_window
{
2066 abi_ulong locals
[8];
2070 #define TARGET_STACK_BIAS 2047
2072 /* {set, get}context() needed for 64-bit SparcLinux userland. */
2073 void sparc64_set_context(CPUSPARCState
*env
)
2076 struct target_ucontext
*ucp
;
2077 target_mc_gregset_t
*grp
;
2078 abi_ulong pc
, npc
, tstate
;
2079 abi_ulong fp
, i7
, w_addr
;
2080 unsigned char fenab
;
2084 ucp_addr
= env
->regwptr
[UREG_I0
];
2085 if (!lock_user_struct(VERIFY_READ
, ucp
, ucp_addr
, 1))
2087 grp
= &ucp
->uc_mcontext
.mc_gregs
;
2088 err
= __get_user(pc
, &((*grp
)[MC_PC
]));
2089 err
|= __get_user(npc
, &((*grp
)[MC_NPC
]));
2090 if (err
|| ((pc
| npc
) & 3))
2092 if (env
->regwptr
[UREG_I1
]) {
2093 target_sigset_t target_set
;
2096 if (TARGET_NSIG_WORDS
== 1) {
2097 if (__get_user(target_set
.sig
[0], &ucp
->uc_sigmask
.sig
[0]))
2100 abi_ulong
*src
, *dst
;
2101 src
= ucp
->uc_sigmask
.sig
;
2102 dst
= target_set
.sig
;
2103 for (i
= 0; i
< sizeof(target_sigset_t
) / sizeof(abi_ulong
);
2105 err
|= __get_user(*dst
, src
);
2109 target_to_host_sigset_internal(&set
, &target_set
);
2110 sigprocmask(SIG_SETMASK
, &set
, NULL
);
2114 err
|= __get_user(env
->y
, &((*grp
)[MC_Y
]));
2115 err
|= __get_user(tstate
, &((*grp
)[MC_TSTATE
]));
2116 env
->asi
= (tstate
>> 24) & 0xff;
2117 PUT_CCR(env
, tstate
>> 32);
2118 PUT_CWP64(env
, tstate
& 0x1f);
2119 err
|= __get_user(env
->gregs
[1], (&(*grp
)[MC_G1
]));
2120 err
|= __get_user(env
->gregs
[2], (&(*grp
)[MC_G2
]));
2121 err
|= __get_user(env
->gregs
[3], (&(*grp
)[MC_G3
]));
2122 err
|= __get_user(env
->gregs
[4], (&(*grp
)[MC_G4
]));
2123 err
|= __get_user(env
->gregs
[5], (&(*grp
)[MC_G5
]));
2124 err
|= __get_user(env
->gregs
[6], (&(*grp
)[MC_G6
]));
2125 err
|= __get_user(env
->gregs
[7], (&(*grp
)[MC_G7
]));
2126 err
|= __get_user(env
->regwptr
[UREG_I0
], (&(*grp
)[MC_O0
]));
2127 err
|= __get_user(env
->regwptr
[UREG_I1
], (&(*grp
)[MC_O1
]));
2128 err
|= __get_user(env
->regwptr
[UREG_I2
], (&(*grp
)[MC_O2
]));
2129 err
|= __get_user(env
->regwptr
[UREG_I3
], (&(*grp
)[MC_O3
]));
2130 err
|= __get_user(env
->regwptr
[UREG_I4
], (&(*grp
)[MC_O4
]));
2131 err
|= __get_user(env
->regwptr
[UREG_I5
], (&(*grp
)[MC_O5
]));
2132 err
|= __get_user(env
->regwptr
[UREG_I6
], (&(*grp
)[MC_O6
]));
2133 err
|= __get_user(env
->regwptr
[UREG_I7
], (&(*grp
)[MC_O7
]));
2135 err
|= __get_user(fp
, &(ucp
->uc_mcontext
.mc_fp
));
2136 err
|= __get_user(i7
, &(ucp
->uc_mcontext
.mc_i7
));
2138 w_addr
= TARGET_STACK_BIAS
+env
->regwptr
[UREG_I6
];
2139 if (put_user(fp
, w_addr
+ offsetof(struct target_reg_window
, ins
[6]),
2142 if (put_user(i7
, w_addr
+ offsetof(struct target_reg_window
, ins
[7]),
2145 err
|= __get_user(fenab
, &(ucp
->uc_mcontext
.mc_fpregs
.mcfpu_enab
));
2146 err
|= __get_user(env
->fprs
, &(ucp
->uc_mcontext
.mc_fpregs
.mcfpu_fprs
));
2148 uint32_t *src
, *dst
;
2149 src
= ucp
->uc_mcontext
.mc_fpregs
.mcfpu_fregs
.sregs
;
2151 /* XXX: check that the CPU storage is the same as user context */
2152 for (i
= 0; i
< 64; i
++, dst
++, src
++)
2153 err
|= __get_user(*dst
, src
);
2155 err
|= __get_user(env
->fsr
,
2156 &(ucp
->uc_mcontext
.mc_fpregs
.mcfpu_fsr
));
2157 err
|= __get_user(env
->gsr
,
2158 &(ucp
->uc_mcontext
.mc_fpregs
.mcfpu_gsr
));
2161 unlock_user_struct(ucp
, ucp_addr
, 0);
2164 unlock_user_struct(ucp
, ucp_addr
, 0);
2168 void sparc64_get_context(CPUSPARCState
*env
)
2171 struct target_ucontext
*ucp
;
2172 target_mc_gregset_t
*grp
;
2173 target_mcontext_t
*mcp
;
2174 abi_ulong fp
, i7
, w_addr
;
2177 target_sigset_t target_set
;
2180 ucp_addr
= env
->regwptr
[UREG_I0
];
2181 if (!lock_user_struct(VERIFY_WRITE
, ucp
, ucp_addr
, 0))
2184 mcp
= &ucp
->uc_mcontext
;
2185 grp
= &mcp
->mc_gregs
;
2187 /* Skip over the trap instruction, first. */
2193 sigprocmask(0, NULL
, &set
);
2194 host_to_target_sigset_internal(&target_set
, &set
);
2195 if (TARGET_NSIG_WORDS
== 1) {
2196 err
|= __put_user(target_set
.sig
[0],
2197 (abi_ulong
*)&ucp
->uc_sigmask
);
2199 abi_ulong
*src
, *dst
;
2200 src
= target_set
.sig
;
2201 dst
= ucp
->uc_sigmask
.sig
;
2202 for (i
= 0; i
< sizeof(target_sigset_t
) / sizeof(abi_ulong
);
2204 err
|= __put_user(*src
, dst
);
2209 /* XXX: tstate must be saved properly */
2210 // err |= __put_user(env->tstate, &((*grp)[MC_TSTATE]));
2211 err
|= __put_user(env
->pc
, &((*grp
)[MC_PC
]));
2212 err
|= __put_user(env
->npc
, &((*grp
)[MC_NPC
]));
2213 err
|= __put_user(env
->y
, &((*grp
)[MC_Y
]));
2214 err
|= __put_user(env
->gregs
[1], &((*grp
)[MC_G1
]));
2215 err
|= __put_user(env
->gregs
[2], &((*grp
)[MC_G2
]));
2216 err
|= __put_user(env
->gregs
[3], &((*grp
)[MC_G3
]));
2217 err
|= __put_user(env
->gregs
[4], &((*grp
)[MC_G4
]));
2218 err
|= __put_user(env
->gregs
[5], &((*grp
)[MC_G5
]));
2219 err
|= __put_user(env
->gregs
[6], &((*grp
)[MC_G6
]));
2220 err
|= __put_user(env
->gregs
[7], &((*grp
)[MC_G7
]));
2221 err
|= __put_user(env
->regwptr
[UREG_I0
], &((*grp
)[MC_O0
]));
2222 err
|= __put_user(env
->regwptr
[UREG_I1
], &((*grp
)[MC_O1
]));
2223 err
|= __put_user(env
->regwptr
[UREG_I2
], &((*grp
)[MC_O2
]));
2224 err
|= __put_user(env
->regwptr
[UREG_I3
], &((*grp
)[MC_O3
]));
2225 err
|= __put_user(env
->regwptr
[UREG_I4
], &((*grp
)[MC_O4
]));
2226 err
|= __put_user(env
->regwptr
[UREG_I5
], &((*grp
)[MC_O5
]));
2227 err
|= __put_user(env
->regwptr
[UREG_I6
], &((*grp
)[MC_O6
]));
2228 err
|= __put_user(env
->regwptr
[UREG_I7
], &((*grp
)[MC_O7
]));
2230 w_addr
= TARGET_STACK_BIAS
+env
->regwptr
[UREG_I6
];
2232 if (get_user(fp
, w_addr
+ offsetof(struct target_reg_window
, ins
[6]),
2235 if (get_user(i7
, w_addr
+ offsetof(struct target_reg_window
, ins
[7]),
2238 err
|= __put_user(fp
, &(mcp
->mc_fp
));
2239 err
|= __put_user(i7
, &(mcp
->mc_i7
));
2242 uint32_t *src
, *dst
;
2244 dst
= ucp
->uc_mcontext
.mc_fpregs
.mcfpu_fregs
.sregs
;
2245 /* XXX: check that the CPU storage is the same as user context */
2246 for (i
= 0; i
< 64; i
++, dst
++, src
++)
2247 err
|= __put_user(*src
, dst
);
2249 err
|= __put_user(env
->fsr
, &(mcp
->mc_fpregs
.mcfpu_fsr
));
2250 err
|= __put_user(env
->gsr
, &(mcp
->mc_fpregs
.mcfpu_gsr
));
2251 err
|= __put_user(env
->fprs
, &(mcp
->mc_fpregs
.mcfpu_fprs
));
2255 unlock_user_struct(ucp
, ucp_addr
, 1);
2258 unlock_user_struct(ucp
, ucp_addr
, 1);
2262 #elif defined(TARGET_ABI_MIPSN64)
2264 # warning signal handling not implemented
2266 static void setup_frame(int sig
, struct target_sigaction
*ka
,
2267 target_sigset_t
*set
, CPUState
*env
)
2269 fprintf(stderr
, "setup_frame: not implemented\n");
2272 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
2273 target_siginfo_t
*info
,
2274 target_sigset_t
*set
, CPUState
*env
)
2276 fprintf(stderr
, "setup_rt_frame: not implemented\n");
2279 long do_sigreturn(CPUState
*env
)
2281 fprintf(stderr
, "do_sigreturn: not implemented\n");
2282 return -TARGET_ENOSYS
;
2285 long do_rt_sigreturn(CPUState
*env
)
2287 fprintf(stderr
, "do_rt_sigreturn: not implemented\n");
2288 return -TARGET_ENOSYS
;
2291 #elif defined(TARGET_ABI_MIPSN32)
2293 # warning signal handling not implemented
2295 static void setup_frame(int sig
, struct target_sigaction
*ka
,
2296 target_sigset_t
*set
, CPUState
*env
)
2298 fprintf(stderr
, "setup_frame: not implemented\n");
2301 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
2302 target_siginfo_t
*info
,
2303 target_sigset_t
*set
, CPUState
*env
)
2305 fprintf(stderr
, "setup_rt_frame: not implemented\n");
2308 long do_sigreturn(CPUState
*env
)
2310 fprintf(stderr
, "do_sigreturn: not implemented\n");
2311 return -TARGET_ENOSYS
;
2314 long do_rt_sigreturn(CPUState
*env
)
2316 fprintf(stderr
, "do_rt_sigreturn: not implemented\n");
2317 return -TARGET_ENOSYS
;
2320 #elif defined(TARGET_ABI_MIPSO32)
2322 struct target_sigcontext
{
2323 uint32_t sc_regmask
; /* Unused */
2326 uint64_t sc_regs
[32];
2327 uint64_t sc_fpregs
[32];
2328 uint32_t sc_ownedfp
; /* Unused */
2329 uint32_t sc_fpc_csr
;
2330 uint32_t sc_fpc_eir
; /* Unused */
2331 uint32_t sc_used_math
;
2332 uint32_t sc_dsp
; /* dsp status, was sc_ssflags */
2336 target_ulong sc_hi1
; /* Was sc_cause */
2337 target_ulong sc_lo1
; /* Was sc_badvaddr */
2338 target_ulong sc_hi2
; /* Was sc_sigset[4] */
2339 target_ulong sc_lo2
;
2340 target_ulong sc_hi3
;
2341 target_ulong sc_lo3
;
2345 uint32_t sf_ass
[4]; /* argument save space for o32 */
2346 uint32_t sf_code
[2]; /* signal trampoline */
2347 struct target_sigcontext sf_sc
;
2348 target_sigset_t sf_mask
;
2351 struct target_ucontext
{
2352 target_ulong uc_flags
;
2353 target_ulong uc_link
;
2354 target_stack_t uc_stack
;
2356 struct target_sigcontext uc_mcontext
;
2357 target_sigset_t uc_sigmask
;
2360 struct target_rt_sigframe
{
2361 uint32_t rs_ass
[4]; /* argument save space for o32 */
2362 uint32_t rs_code
[2]; /* signal trampoline */
2363 struct target_siginfo rs_info
;
2364 struct target_ucontext rs_uc
;
2367 /* Install trampoline to jump back from signal handler */
2368 static inline int install_sigtramp(unsigned int *tramp
, unsigned int syscall
)
2373 * Set up the return code ...
2375 * li v0, __NR__foo_sigreturn
2379 err
= __put_user(0x24020000 + syscall
, tramp
+ 0);
2380 err
|= __put_user(0x0000000c , tramp
+ 1);
2381 /* flush_cache_sigtramp((unsigned long) tramp); */
2386 setup_sigcontext(CPUState
*regs
, struct target_sigcontext
*sc
)
2390 err
|= __put_user(regs
->active_tc
.PC
, &sc
->sc_pc
);
2392 #define save_gp_reg(i) do { \
2393 err |= __put_user(regs->active_tc.gpr[i], &sc->sc_regs[i]); \
2395 __put_user(0, &sc
->sc_regs
[0]); save_gp_reg(1); save_gp_reg(2);
2396 save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
2397 save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
2398 save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
2399 save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
2400 save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
2401 save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
2402 save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
2406 err
|= __put_user(regs
->active_tc
.HI
[0], &sc
->sc_mdhi
);
2407 err
|= __put_user(regs
->active_tc
.LO
[0], &sc
->sc_mdlo
);
2409 /* Not used yet, but might be useful if we ever have DSP suppport */
2412 err
|= __put_user(mfhi1(), &sc
->sc_hi1
);
2413 err
|= __put_user(mflo1(), &sc
->sc_lo1
);
2414 err
|= __put_user(mfhi2(), &sc
->sc_hi2
);
2415 err
|= __put_user(mflo2(), &sc
->sc_lo2
);
2416 err
|= __put_user(mfhi3(), &sc
->sc_hi3
);
2417 err
|= __put_user(mflo3(), &sc
->sc_lo3
);
2418 err
|= __put_user(rddsp(DSP_MASK
), &sc
->sc_dsp
);
2420 /* same with 64 bit */
2422 err
|= __put_user(regs
->hi
, &sc
->sc_hi
[0]);
2423 err
|= __put_user(regs
->lo
, &sc
->sc_lo
[0]);
2425 err
|= __put_user(mfhi1(), &sc
->sc_hi
[1]);
2426 err
|= __put_user(mflo1(), &sc
->sc_lo
[1]);
2427 err
|= __put_user(mfhi2(), &sc
->sc_hi
[2]);
2428 err
|= __put_user(mflo2(), &sc
->sc_lo
[2]);
2429 err
|= __put_user(mfhi3(), &sc
->sc_hi
[3]);
2430 err
|= __put_user(mflo3(), &sc
->sc_lo
[3]);
2431 err
|= __put_user(rddsp(DSP_MASK
), &sc
->sc_dsp
);
2437 err
|= __put_user(!!used_math(), &sc
->sc_used_math
);
2443 * Save FPU state to signal context. Signal handler will "inherit"
2444 * current FPU state.
2448 if (!is_fpu_owner()) {
2450 restore_fp(current
);
2452 err
|= save_fp_context(sc
);
2461 restore_sigcontext(CPUState
*regs
, struct target_sigcontext
*sc
)
2465 err
|= __get_user(regs
->CP0_EPC
, &sc
->sc_pc
);
2467 err
|= __get_user(regs
->active_tc
.HI
[0], &sc
->sc_mdhi
);
2468 err
|= __get_user(regs
->active_tc
.LO
[0], &sc
->sc_mdlo
);
2470 #define restore_gp_reg(i) do { \
2471 err |= __get_user(regs->active_tc.gpr[i], &sc->sc_regs[i]); \
2473 restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
2474 restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
2475 restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
2476 restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
2477 restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
2478 restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
2479 restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
2480 restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
2481 restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
2482 restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
2484 #undef restore_gp_reg
2488 err
|= __get_user(treg
, &sc
->sc_hi1
); mthi1(treg
);
2489 err
|= __get_user(treg
, &sc
->sc_lo1
); mtlo1(treg
);
2490 err
|= __get_user(treg
, &sc
->sc_hi2
); mthi2(treg
);
2491 err
|= __get_user(treg
, &sc
->sc_lo2
); mtlo2(treg
);
2492 err
|= __get_user(treg
, &sc
->sc_hi3
); mthi3(treg
);
2493 err
|= __get_user(treg
, &sc
->sc_lo3
); mtlo3(treg
);
2494 err
|= __get_user(treg
, &sc
->sc_dsp
); wrdsp(treg
, DSP_MASK
);
2497 err
|= __get_user(regs
->hi
, &sc
->sc_hi
[0]);
2498 err
|= __get_user(regs
->lo
, &sc
->sc_lo
[0]);
2500 err
|= __get_user(treg
, &sc
->sc_hi
[1]); mthi1(treg
);
2501 err
|= __get_user(treg
, &sc
->sc_lo
[1]); mthi1(treg
);
2502 err
|= __get_user(treg
, &sc
->sc_hi
[2]); mthi2(treg
);
2503 err
|= __get_user(treg
, &sc
->sc_lo
[2]); mthi2(treg
);
2504 err
|= __get_user(treg
, &sc
->sc_hi
[3]); mthi3(treg
);
2505 err
|= __get_user(treg
, &sc
->sc_lo
[3]); mthi3(treg
);
2506 err
|= __get_user(treg
, &sc
->sc_dsp
); wrdsp(treg
, DSP_MASK
);
2510 err
|= __get_user(used_math
, &sc
->sc_used_math
);
2511 conditional_used_math(used_math
);
2516 /* restore fpu context if we have used it before */
2518 err
|= restore_fp_context(sc
);
2520 /* signal handler may have used FPU. Give it up. */
2529 * Determine which stack to use..
2531 static inline abi_ulong
2532 get_sigframe(struct target_sigaction
*ka
, CPUState
*regs
, size_t frame_size
)
2536 /* Default to using normal stack */
2537 sp
= regs
->active_tc
.gpr
[29];
2540 * FPU emulator may have it's own trampoline active just
2541 * above the user stack, 16-bytes before the next lowest
2542 * 16 byte boundary. Try to avoid trashing it.
2546 /* This is the X/Open sanctioned signal stack switching. */
2547 if ((ka
->sa_flags
& TARGET_SA_ONSTACK
) && (sas_ss_flags (sp
) == 0)) {
2548 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
2551 return (sp
- frame_size
) & ~7;
2554 /* compare linux/arch/mips/kernel/signal.c:setup_frame() */
2555 static void setup_frame(int sig
, struct target_sigaction
* ka
,
2556 target_sigset_t
*set
, CPUState
*regs
)
2558 struct sigframe
*frame
;
2559 abi_ulong frame_addr
;
2562 frame_addr
= get_sigframe(ka
, regs
, sizeof(*frame
));
2563 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
2566 install_sigtramp(frame
->sf_code
, TARGET_NR_sigreturn
);
2568 if(setup_sigcontext(regs
, &frame
->sf_sc
))
2571 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
2572 if(__put_user(set
->sig
[i
], &frame
->sf_mask
.sig
[i
]))
2577 * Arguments to signal handler:
2579 * a0 = signal number
2580 * a1 = 0 (should be cause)
2581 * a2 = pointer to struct sigcontext
2583 * $25 and PC point to the signal handler, $29 points to the
2586 regs
->active_tc
.gpr
[ 4] = sig
;
2587 regs
->active_tc
.gpr
[ 5] = 0;
2588 regs
->active_tc
.gpr
[ 6] = frame_addr
+ offsetof(struct sigframe
, sf_sc
);
2589 regs
->active_tc
.gpr
[29] = frame_addr
;
2590 regs
->active_tc
.gpr
[31] = frame_addr
+ offsetof(struct sigframe
, sf_code
);
2591 /* The original kernel code sets CP0_EPC to the handler
2592 * since it returns to userland using eret
2593 * we cannot do this here, and we must set PC directly */
2594 regs
->active_tc
.PC
= regs
->active_tc
.gpr
[25] = ka
->_sa_handler
;
2595 unlock_user_struct(frame
, frame_addr
, 1);
2599 unlock_user_struct(frame
, frame_addr
, 1);
2600 force_sig(TARGET_SIGSEGV
/*, current*/);
2604 long do_sigreturn(CPUState
*regs
)
2606 struct sigframe
*frame
;
2607 abi_ulong frame_addr
;
2609 target_sigset_t target_set
;
2612 #if defined(DEBUG_SIGNAL)
2613 fprintf(stderr
, "do_sigreturn\n");
2615 frame_addr
= regs
->active_tc
.gpr
[29];
2616 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
2619 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
2620 if(__get_user(target_set
.sig
[i
], &frame
->sf_mask
.sig
[i
]))
2624 target_to_host_sigset_internal(&blocked
, &target_set
);
2625 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
2627 if (restore_sigcontext(regs
, &frame
->sf_sc
))
2632 * Don't let your children do this ...
2634 __asm__
__volatile__(
2642 regs
->active_tc
.PC
= regs
->CP0_EPC
;
2643 /* I am not sure this is right, but it seems to work
2644 * maybe a problem with nested signals ? */
2646 return -TARGET_QEMU_ESIGRETURN
;
2649 force_sig(TARGET_SIGSEGV
/*, current*/);
2653 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
2654 target_siginfo_t
*info
,
2655 target_sigset_t
*set
, CPUState
*env
)
2657 struct target_rt_sigframe
*frame
;
2658 abi_ulong frame_addr
;
2661 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
2662 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
2665 install_sigtramp(frame
->rs_code
, TARGET_NR_rt_sigreturn
);
2667 copy_siginfo_to_user(&frame
->rs_info
, info
);
2669 __put_user(0, &frame
->rs_uc
.uc_flags
);
2670 __put_user(0, &frame
->rs_uc
.uc_link
);
2671 __put_user(target_sigaltstack_used
.ss_sp
, &frame
->rs_uc
.uc_stack
.ss_sp
);
2672 __put_user(target_sigaltstack_used
.ss_size
, &frame
->rs_uc
.uc_stack
.ss_size
);
2673 __put_user(sas_ss_flags(get_sp_from_cpustate(env
)),
2674 &frame
->rs_uc
.uc_stack
.ss_flags
);
2676 setup_sigcontext(env
, &frame
->rs_uc
.uc_mcontext
);
2678 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
2679 __put_user(set
->sig
[i
], &frame
->rs_uc
.uc_sigmask
.sig
[i
]);
2683 * Arguments to signal handler:
2685 * a0 = signal number
2686 * a1 = pointer to struct siginfo
2687 * a2 = pointer to struct ucontext
2689 * $25 and PC point to the signal handler, $29 points to the
2692 env
->active_tc
.gpr
[ 4] = sig
;
2693 env
->active_tc
.gpr
[ 5] = frame_addr
2694 + offsetof(struct target_rt_sigframe
, rs_info
);
2695 env
->active_tc
.gpr
[ 6] = frame_addr
2696 + offsetof(struct target_rt_sigframe
, rs_uc
);
2697 env
->active_tc
.gpr
[29] = frame_addr
;
2698 env
->active_tc
.gpr
[31] = frame_addr
2699 + offsetof(struct target_rt_sigframe
, rs_code
);
2700 /* The original kernel code sets CP0_EPC to the handler
2701 * since it returns to userland using eret
2702 * we cannot do this here, and we must set PC directly */
2703 env
->active_tc
.PC
= env
->active_tc
.gpr
[25] = ka
->_sa_handler
;
2704 unlock_user_struct(frame
, frame_addr
, 1);
2708 unlock_user_struct(frame
, frame_addr
, 1);
2709 force_sig(TARGET_SIGSEGV
/*, current*/);
2713 long do_rt_sigreturn(CPUState
*env
)
2715 struct target_rt_sigframe
*frame
;
2716 abi_ulong frame_addr
;
2719 #if defined(DEBUG_SIGNAL)
2720 fprintf(stderr
, "do_rt_sigreturn\n");
2722 frame_addr
= env
->active_tc
.gpr
[29];
2723 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
2726 target_to_host_sigset(&blocked
, &frame
->rs_uc
.uc_sigmask
);
2727 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
2729 if (restore_sigcontext(env
, &frame
->rs_uc
.uc_mcontext
))
2732 if (do_sigaltstack(frame_addr
+
2733 offsetof(struct target_rt_sigframe
, rs_uc
.uc_stack
),
2734 0, get_sp_from_cpustate(env
)) == -EFAULT
)
2737 env
->active_tc
.PC
= env
->CP0_EPC
;
2738 /* I am not sure this is right, but it seems to work
2739 * maybe a problem with nested signals ? */
2741 return -TARGET_QEMU_ESIGRETURN
;
2744 force_sig(TARGET_SIGSEGV
/*, current*/);
2748 #elif defined(TARGET_SH4)
2751 * code and data structures from linux kernel:
2752 * include/asm-sh/sigcontext.h
2753 * arch/sh/kernel/signal.c
2756 struct target_sigcontext
{
2757 target_ulong oldmask
;
2760 target_ulong sc_gregs
[16];
2764 target_ulong sc_gbr
;
2765 target_ulong sc_mach
;
2766 target_ulong sc_macl
;
2769 target_ulong sc_fpregs
[16];
2770 target_ulong sc_xfpregs
[16];
2771 unsigned int sc_fpscr
;
2772 unsigned int sc_fpul
;
2773 unsigned int sc_ownedfp
;
2776 struct target_sigframe
2778 struct target_sigcontext sc
;
2779 target_ulong extramask
[TARGET_NSIG_WORDS
-1];
2780 uint16_t retcode
[3];
2784 struct target_ucontext
{
2785 target_ulong uc_flags
;
2786 struct target_ucontext
*uc_link
;
2787 target_stack_t uc_stack
;
2788 struct target_sigcontext uc_mcontext
;
2789 target_sigset_t uc_sigmask
; /* mask last for extensibility */
2792 struct target_rt_sigframe
2794 struct target_siginfo info
;
2795 struct target_ucontext uc
;
2796 uint16_t retcode
[3];
2800 #define MOVW(n) (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */
2801 #define TRAP_NOARG 0xc310 /* Syscall w/no args (NR in R3) SH3/4 */
2803 static abi_ulong
get_sigframe(struct target_sigaction
*ka
,
2804 unsigned long sp
, size_t frame_size
)
2806 if ((ka
->sa_flags
& TARGET_SA_ONSTACK
) && (sas_ss_flags(sp
) == 0)) {
2807 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
2810 return (sp
- frame_size
) & -8ul;
2813 static int setup_sigcontext(struct target_sigcontext
*sc
,
2814 CPUState
*regs
, unsigned long mask
)
2818 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
2819 COPY(gregs
[0]); COPY(gregs
[1]);
2820 COPY(gregs
[2]); COPY(gregs
[3]);
2821 COPY(gregs
[4]); COPY(gregs
[5]);
2822 COPY(gregs
[6]); COPY(gregs
[7]);
2823 COPY(gregs
[8]); COPY(gregs
[9]);
2824 COPY(gregs
[10]); COPY(gregs
[11]);
2825 COPY(gregs
[12]); COPY(gregs
[13]);
2826 COPY(gregs
[14]); COPY(gregs
[15]);
2827 COPY(gbr
); COPY(mach
);
2828 COPY(macl
); COPY(pr
);
2832 /* todo: save FPU registers here */
2834 /* non-iBCS2 extensions.. */
2835 err
|= __put_user(mask
, &sc
->oldmask
);
2840 static int restore_sigcontext(CPUState
*regs
,
2841 struct target_sigcontext
*sc
)
2843 unsigned int err
= 0;
2845 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
2847 COPY(gregs
[2]); COPY(gregs
[3]);
2848 COPY(gregs
[4]); COPY(gregs
[5]);
2849 COPY(gregs
[6]); COPY(gregs
[7]);
2850 COPY(gregs
[8]); COPY(gregs
[9]);
2851 COPY(gregs
[10]); COPY(gregs
[11]);
2852 COPY(gregs
[12]); COPY(gregs
[13]);
2853 COPY(gregs
[14]); COPY(gregs
[15]);
2854 COPY(gbr
); COPY(mach
);
2855 COPY(macl
); COPY(pr
);
2859 /* todo: restore FPU registers here */
2861 regs
->tra
= -1; /* disable syscall checks */
2865 static void setup_frame(int sig
, struct target_sigaction
*ka
,
2866 target_sigset_t
*set
, CPUState
*regs
)
2868 struct target_sigframe
*frame
;
2869 abi_ulong frame_addr
;
2874 frame_addr
= get_sigframe(ka
, regs
->gregs
[15], sizeof(*frame
));
2875 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
2878 signal
= current_exec_domain_sig(sig
);
2880 err
|= setup_sigcontext(&frame
->sc
, regs
, set
->sig
[0]);
2882 for (i
= 0; i
< TARGET_NSIG_WORDS
- 1; i
++) {
2883 err
|= __put_user(set
->sig
[i
+ 1], &frame
->extramask
[i
]);
2886 /* Set up to return from userspace. If provided, use a stub
2887 already in userspace. */
2888 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
2889 regs
->pr
= (unsigned long) ka
->sa_restorer
;
2891 /* Generate return code (system call to sigreturn) */
2892 err
|= __put_user(MOVW(2), &frame
->retcode
[0]);
2893 err
|= __put_user(TRAP_NOARG
, &frame
->retcode
[1]);
2894 err
|= __put_user((TARGET_NR_sigreturn
), &frame
->retcode
[2]);
2895 regs
->pr
= (unsigned long) frame
->retcode
;
2901 /* Set up registers for signal handler */
2902 regs
->gregs
[15] = (unsigned long) frame
;
2903 regs
->gregs
[4] = signal
; /* Arg for signal handler */
2905 regs
->gregs
[6] = (unsigned long) &frame
->sc
;
2906 regs
->pc
= (unsigned long) ka
->_sa_handler
;
2908 unlock_user_struct(frame
, frame_addr
, 1);
2912 unlock_user_struct(frame
, frame_addr
, 1);
2916 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
2917 target_siginfo_t
*info
,
2918 target_sigset_t
*set
, CPUState
*regs
)
2920 struct target_rt_sigframe
*frame
;
2921 abi_ulong frame_addr
;
2926 frame_addr
= get_sigframe(ka
, regs
->gregs
[15], sizeof(*frame
));
2927 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
2930 signal
= current_exec_domain_sig(sig
);
2932 err
|= copy_siginfo_to_user(&frame
->info
, info
);
2934 /* Create the ucontext. */
2935 err
|= __put_user(0, &frame
->uc
.uc_flags
);
2936 err
|= __put_user(0, (unsigned long *)&frame
->uc
.uc_link
);
2937 err
|= __put_user((unsigned long)target_sigaltstack_used
.ss_sp
,
2938 &frame
->uc
.uc_stack
.ss_sp
);
2939 err
|= __put_user(sas_ss_flags(regs
->gregs
[15]),
2940 &frame
->uc
.uc_stack
.ss_flags
);
2941 err
|= __put_user(target_sigaltstack_used
.ss_size
,
2942 &frame
->uc
.uc_stack
.ss_size
);
2943 err
|= setup_sigcontext(&frame
->uc
.uc_mcontext
,
2945 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
2946 err
|= __put_user(set
->sig
[i
], &frame
->uc
.uc_sigmask
.sig
[i
]);
2949 /* Set up to return from userspace. If provided, use a stub
2950 already in userspace. */
2951 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
2952 regs
->pr
= (unsigned long) ka
->sa_restorer
;
2954 /* Generate return code (system call to sigreturn) */
2955 err
|= __put_user(MOVW(2), &frame
->retcode
[0]);
2956 err
|= __put_user(TRAP_NOARG
, &frame
->retcode
[1]);
2957 err
|= __put_user((TARGET_NR_rt_sigreturn
), &frame
->retcode
[2]);
2958 regs
->pr
= (unsigned long) frame
->retcode
;
2964 /* Set up registers for signal handler */
2965 regs
->gregs
[15] = (unsigned long) frame
;
2966 regs
->gregs
[4] = signal
; /* Arg for signal handler */
2967 regs
->gregs
[5] = (unsigned long) &frame
->info
;
2968 regs
->gregs
[6] = (unsigned long) &frame
->uc
;
2969 regs
->pc
= (unsigned long) ka
->_sa_handler
;
2971 unlock_user_struct(frame
, frame_addr
, 1);
2975 unlock_user_struct(frame
, frame_addr
, 1);
2979 long do_sigreturn(CPUState
*regs
)
2981 struct target_sigframe
*frame
;
2982 abi_ulong frame_addr
;
2984 target_sigset_t target_set
;
2988 #if defined(DEBUG_SIGNAL)
2989 fprintf(stderr
, "do_sigreturn\n");
2991 frame_addr
= regs
->gregs
[15];
2992 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
2995 err
|= __get_user(target_set
.sig
[0], &frame
->sc
.oldmask
);
2996 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
2997 err
|= (__get_user(target_set
.sig
[i
], &frame
->extramask
[i
- 1]));
3003 target_to_host_sigset_internal(&blocked
, &target_set
);
3004 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
3006 if (restore_sigcontext(regs
, &frame
->sc
))
3009 unlock_user_struct(frame
, frame_addr
, 0);
3010 return regs
->gregs
[0];
3013 unlock_user_struct(frame
, frame_addr
, 0);
3014 force_sig(TARGET_SIGSEGV
);
3018 long do_rt_sigreturn(CPUState
*regs
)
3020 struct target_rt_sigframe
*frame
;
3021 abi_ulong frame_addr
;
3024 #if defined(DEBUG_SIGNAL)
3025 fprintf(stderr
, "do_rt_sigreturn\n");
3027 frame_addr
= regs
->gregs
[15];
3028 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
3031 target_to_host_sigset(&blocked
, &frame
->uc
.uc_sigmask
);
3032 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
3034 if (restore_sigcontext(regs
, &frame
->uc
.uc_mcontext
))
3037 if (do_sigaltstack(frame_addr
+
3038 offsetof(struct target_rt_sigframe
, uc
.uc_stack
),
3039 0, get_sp_from_cpustate(regs
)) == -EFAULT
)
3042 unlock_user_struct(frame
, frame_addr
, 0);
3043 return regs
->gregs
[0];
3046 unlock_user_struct(frame
, frame_addr
, 0);
3047 force_sig(TARGET_SIGSEGV
);
3050 #elif defined(TARGET_MICROBLAZE)
3052 struct target_sigcontext
{
3053 struct target_pt_regs regs
; /* needs to be first */
3057 /* Signal frames. */
3058 struct target_signal_frame
{
3059 struct target_sigcontext sc
;
3060 uint32_t extramask
[TARGET_NSIG_WORDS
- 1];
3064 struct rt_signal_frame
{
3065 struct siginfo info
;
3070 static void setup_sigcontext(struct target_sigcontext
*sc
, CPUState
*env
)
3072 __put_user(env
->regs
[0], &sc
->regs
.r0
);
3073 __put_user(env
->regs
[1], &sc
->regs
.r1
);
3074 __put_user(env
->regs
[2], &sc
->regs
.r2
);
3075 __put_user(env
->regs
[3], &sc
->regs
.r3
);
3076 __put_user(env
->regs
[4], &sc
->regs
.r4
);
3077 __put_user(env
->regs
[5], &sc
->regs
.r5
);
3078 __put_user(env
->regs
[6], &sc
->regs
.r6
);
3079 __put_user(env
->regs
[7], &sc
->regs
.r7
);
3080 __put_user(env
->regs
[8], &sc
->regs
.r8
);
3081 __put_user(env
->regs
[9], &sc
->regs
.r9
);
3082 __put_user(env
->regs
[10], &sc
->regs
.r10
);
3083 __put_user(env
->regs
[11], &sc
->regs
.r11
);
3084 __put_user(env
->regs
[12], &sc
->regs
.r12
);
3085 __put_user(env
->regs
[13], &sc
->regs
.r13
);
3086 __put_user(env
->regs
[14], &sc
->regs
.r14
);
3087 __put_user(env
->regs
[15], &sc
->regs
.r15
);
3088 __put_user(env
->regs
[16], &sc
->regs
.r16
);
3089 __put_user(env
->regs
[17], &sc
->regs
.r17
);
3090 __put_user(env
->regs
[18], &sc
->regs
.r18
);
3091 __put_user(env
->regs
[19], &sc
->regs
.r19
);
3092 __put_user(env
->regs
[20], &sc
->regs
.r20
);
3093 __put_user(env
->regs
[21], &sc
->regs
.r21
);
3094 __put_user(env
->regs
[22], &sc
->regs
.r22
);
3095 __put_user(env
->regs
[23], &sc
->regs
.r23
);
3096 __put_user(env
->regs
[24], &sc
->regs
.r24
);
3097 __put_user(env
->regs
[25], &sc
->regs
.r25
);
3098 __put_user(env
->regs
[26], &sc
->regs
.r26
);
3099 __put_user(env
->regs
[27], &sc
->regs
.r27
);
3100 __put_user(env
->regs
[28], &sc
->regs
.r28
);
3101 __put_user(env
->regs
[29], &sc
->regs
.r29
);
3102 __put_user(env
->regs
[30], &sc
->regs
.r30
);
3103 __put_user(env
->regs
[31], &sc
->regs
.r31
);
3104 __put_user(env
->sregs
[SR_PC
], &sc
->regs
.pc
);
3107 static void restore_sigcontext(struct target_sigcontext
*sc
, CPUState
*env
)
3109 __get_user(env
->regs
[0], &sc
->regs
.r0
);
3110 __get_user(env
->regs
[1], &sc
->regs
.r1
);
3111 __get_user(env
->regs
[2], &sc
->regs
.r2
);
3112 __get_user(env
->regs
[3], &sc
->regs
.r3
);
3113 __get_user(env
->regs
[4], &sc
->regs
.r4
);
3114 __get_user(env
->regs
[5], &sc
->regs
.r5
);
3115 __get_user(env
->regs
[6], &sc
->regs
.r6
);
3116 __get_user(env
->regs
[7], &sc
->regs
.r7
);
3117 __get_user(env
->regs
[8], &sc
->regs
.r8
);
3118 __get_user(env
->regs
[9], &sc
->regs
.r9
);
3119 __get_user(env
->regs
[10], &sc
->regs
.r10
);
3120 __get_user(env
->regs
[11], &sc
->regs
.r11
);
3121 __get_user(env
->regs
[12], &sc
->regs
.r12
);
3122 __get_user(env
->regs
[13], &sc
->regs
.r13
);
3123 __get_user(env
->regs
[14], &sc
->regs
.r14
);
3124 __get_user(env
->regs
[15], &sc
->regs
.r15
);
3125 __get_user(env
->regs
[16], &sc
->regs
.r16
);
3126 __get_user(env
->regs
[17], &sc
->regs
.r17
);
3127 __get_user(env
->regs
[18], &sc
->regs
.r18
);
3128 __get_user(env
->regs
[19], &sc
->regs
.r19
);
3129 __get_user(env
->regs
[20], &sc
->regs
.r20
);
3130 __get_user(env
->regs
[21], &sc
->regs
.r21
);
3131 __get_user(env
->regs
[22], &sc
->regs
.r22
);
3132 __get_user(env
->regs
[23], &sc
->regs
.r23
);
3133 __get_user(env
->regs
[24], &sc
->regs
.r24
);
3134 __get_user(env
->regs
[25], &sc
->regs
.r25
);
3135 __get_user(env
->regs
[26], &sc
->regs
.r26
);
3136 __get_user(env
->regs
[27], &sc
->regs
.r27
);
3137 __get_user(env
->regs
[28], &sc
->regs
.r28
);
3138 __get_user(env
->regs
[29], &sc
->regs
.r29
);
3139 __get_user(env
->regs
[30], &sc
->regs
.r30
);
3140 __get_user(env
->regs
[31], &sc
->regs
.r31
);
3141 __get_user(env
->sregs
[SR_PC
], &sc
->regs
.pc
);
3144 static abi_ulong
get_sigframe(struct target_sigaction
*ka
,
3145 CPUState
*env
, int frame_size
)
3147 abi_ulong sp
= env
->regs
[1];
3149 if ((ka
->sa_flags
& SA_ONSTACK
) != 0 && !on_sig_stack(sp
))
3150 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
3152 return ((sp
- frame_size
) & -8UL);
3155 static void setup_frame(int sig
, struct target_sigaction
*ka
,
3156 target_sigset_t
*set
, CPUState
*env
)
3158 struct target_signal_frame
*frame
;
3159 abi_ulong frame_addr
;
3163 frame_addr
= get_sigframe(ka
, env
, sizeof *frame
);
3164 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
3167 /* Save the mask. */
3168 err
|= __put_user(set
->sig
[0], &frame
->sc
.oldmask
);
3172 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
3173 if (__put_user(set
->sig
[i
], &frame
->extramask
[i
- 1]))
3177 setup_sigcontext(&frame
->sc
, env
);
3179 /* Set up to return from userspace. If provided, use a stub
3180 already in userspace. */
3181 /* minus 8 is offset to cater for "rtsd r15,8" offset */
3182 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
3183 env
->regs
[15] = ((unsigned long)ka
->sa_restorer
)-8;
3186 /* Note, these encodings are _big endian_! */
3187 /* addi r12, r0, __NR_sigreturn */
3188 t
= 0x31800000UL
| TARGET_NR_sigreturn
;
3189 err
|= __put_user(t
, frame
->tramp
+ 0);
3192 err
|= __put_user(t
, frame
->tramp
+ 1);
3194 /* Return from sighandler will jump to the tramp.
3195 Negative 8 offset because return is rtsd r15, 8 */
3196 env
->regs
[15] = ((unsigned long)frame
->tramp
) - 8;
3202 /* Set up registers for signal handler */
3203 env
->regs
[1] = (unsigned long) frame
;
3204 /* Signal handler args: */
3205 env
->regs
[5] = sig
; /* Arg 0: signum */
3206 env
->regs
[6] = (unsigned long) &frame
->sc
; /* arg 1: sigcontext */
3208 /* Offset of 4 to handle microblaze rtid r14, 0 */
3209 env
->sregs
[SR_PC
] = (unsigned long)ka
->_sa_handler
;
3211 unlock_user_struct(frame
, frame_addr
, 1);
3214 unlock_user_struct(frame
, frame_addr
, 1);
3215 force_sig(TARGET_SIGSEGV
);
3218 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
3219 target_siginfo_t
*info
,
3220 target_sigset_t
*set
, CPUState
*env
)
3222 fprintf(stderr
, "Microblaze setup_rt_frame: not implemented\n");
3225 long do_sigreturn(CPUState
*env
)
3227 struct target_signal_frame
*frame
;
3228 abi_ulong frame_addr
;
3229 target_sigset_t target_set
;
3233 frame_addr
= env
->regs
[R_SP
];
3234 /* Make sure the guest isn't playing games. */
3235 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 1))
3238 /* Restore blocked signals */
3239 if (__get_user(target_set
.sig
[0], &frame
->sc
.oldmask
))
3241 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
3242 if (__get_user(target_set
.sig
[i
], &frame
->extramask
[i
- 1]))
3245 target_to_host_sigset_internal(&set
, &target_set
);
3246 sigprocmask(SIG_SETMASK
, &set
, NULL
);
3248 restore_sigcontext(&frame
->sc
, env
);
3249 /* We got here through a sigreturn syscall, our path back is via an
3250 rtb insn so setup r14 for that. */
3251 env
->regs
[14] = env
->sregs
[SR_PC
];
3253 unlock_user_struct(frame
, frame_addr
, 0);
3254 return env
->regs
[10];
3256 unlock_user_struct(frame
, frame_addr
, 0);
3257 force_sig(TARGET_SIGSEGV
);
3260 long do_rt_sigreturn(CPUState
*env
)
3262 fprintf(stderr
, "Microblaze do_rt_sigreturn: not implemented\n");
3263 return -TARGET_ENOSYS
;
3266 #elif defined(TARGET_CRIS)
3268 struct target_sigcontext
{
3269 struct target_pt_regs regs
; /* needs to be first */
3271 uint32_t usp
; /* usp before stacking this gunk on it */
3274 /* Signal frames. */
3275 struct target_signal_frame
{
3276 struct target_sigcontext sc
;
3277 uint32_t extramask
[TARGET_NSIG_WORDS
- 1];
3278 uint8_t retcode
[8]; /* Trampoline code. */
3281 struct rt_signal_frame
{
3282 struct siginfo
*pinfo
;
3284 struct siginfo info
;
3286 uint8_t retcode
[8]; /* Trampoline code. */
3289 static void setup_sigcontext(struct target_sigcontext
*sc
, CPUState
*env
)
3291 __put_user(env
->regs
[0], &sc
->regs
.r0
);
3292 __put_user(env
->regs
[1], &sc
->regs
.r1
);
3293 __put_user(env
->regs
[2], &sc
->regs
.r2
);
3294 __put_user(env
->regs
[3], &sc
->regs
.r3
);
3295 __put_user(env
->regs
[4], &sc
->regs
.r4
);
3296 __put_user(env
->regs
[5], &sc
->regs
.r5
);
3297 __put_user(env
->regs
[6], &sc
->regs
.r6
);
3298 __put_user(env
->regs
[7], &sc
->regs
.r7
);
3299 __put_user(env
->regs
[8], &sc
->regs
.r8
);
3300 __put_user(env
->regs
[9], &sc
->regs
.r9
);
3301 __put_user(env
->regs
[10], &sc
->regs
.r10
);
3302 __put_user(env
->regs
[11], &sc
->regs
.r11
);
3303 __put_user(env
->regs
[12], &sc
->regs
.r12
);
3304 __put_user(env
->regs
[13], &sc
->regs
.r13
);
3305 __put_user(env
->regs
[14], &sc
->usp
);
3306 __put_user(env
->regs
[15], &sc
->regs
.acr
);
3307 __put_user(env
->pregs
[PR_MOF
], &sc
->regs
.mof
);
3308 __put_user(env
->pregs
[PR_SRP
], &sc
->regs
.srp
);
3309 __put_user(env
->pc
, &sc
->regs
.erp
);
3312 static void restore_sigcontext(struct target_sigcontext
*sc
, CPUState
*env
)
3314 __get_user(env
->regs
[0], &sc
->regs
.r0
);
3315 __get_user(env
->regs
[1], &sc
->regs
.r1
);
3316 __get_user(env
->regs
[2], &sc
->regs
.r2
);
3317 __get_user(env
->regs
[3], &sc
->regs
.r3
);
3318 __get_user(env
->regs
[4], &sc
->regs
.r4
);
3319 __get_user(env
->regs
[5], &sc
->regs
.r5
);
3320 __get_user(env
->regs
[6], &sc
->regs
.r6
);
3321 __get_user(env
->regs
[7], &sc
->regs
.r7
);
3322 __get_user(env
->regs
[8], &sc
->regs
.r8
);
3323 __get_user(env
->regs
[9], &sc
->regs
.r9
);
3324 __get_user(env
->regs
[10], &sc
->regs
.r10
);
3325 __get_user(env
->regs
[11], &sc
->regs
.r11
);
3326 __get_user(env
->regs
[12], &sc
->regs
.r12
);
3327 __get_user(env
->regs
[13], &sc
->regs
.r13
);
3328 __get_user(env
->regs
[14], &sc
->usp
);
3329 __get_user(env
->regs
[15], &sc
->regs
.acr
);
3330 __get_user(env
->pregs
[PR_MOF
], &sc
->regs
.mof
);
3331 __get_user(env
->pregs
[PR_SRP
], &sc
->regs
.srp
);
3332 __get_user(env
->pc
, &sc
->regs
.erp
);
3335 static abi_ulong
get_sigframe(CPUState
*env
, int framesize
)
3338 /* Align the stack downwards to 4. */
3339 sp
= (env
->regs
[R_SP
] & ~3);
3340 return sp
- framesize
;
3343 static void setup_frame(int sig
, struct target_sigaction
*ka
,
3344 target_sigset_t
*set
, CPUState
*env
)
3346 struct target_signal_frame
*frame
;
3347 abi_ulong frame_addr
;
3351 frame_addr
= get_sigframe(env
, sizeof *frame
);
3352 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
3356 * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't
3357 * use this trampoline anymore but it sets it up for GDB.
3358 * In QEMU, using the trampoline simplifies things a bit so we use it.
3360 * This is movu.w __NR_sigreturn, r9; break 13;
3362 err
|= __put_user(0x9c5f, frame
->retcode
+0);
3363 err
|= __put_user(TARGET_NR_sigreturn
,
3365 err
|= __put_user(0xe93d, frame
->retcode
+4);
3367 /* Save the mask. */
3368 err
|= __put_user(set
->sig
[0], &frame
->sc
.oldmask
);
3372 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
3373 if (__put_user(set
->sig
[i
], &frame
->extramask
[i
- 1]))
3377 setup_sigcontext(&frame
->sc
, env
);
3379 /* Move the stack and setup the arguments for the handler. */
3380 env
->regs
[R_SP
] = (uint32_t) (unsigned long) frame
;
3381 env
->regs
[10] = sig
;
3382 env
->pc
= (unsigned long) ka
->_sa_handler
;
3383 /* Link SRP so the guest returns through the trampoline. */
3384 env
->pregs
[PR_SRP
] = (uint32_t) (unsigned long) &frame
->retcode
[0];
3386 unlock_user_struct(frame
, frame_addr
, 1);
3389 unlock_user_struct(frame
, frame_addr
, 1);
3390 force_sig(TARGET_SIGSEGV
);
3393 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
3394 target_siginfo_t
*info
,
3395 target_sigset_t
*set
, CPUState
*env
)
3397 fprintf(stderr
, "CRIS setup_rt_frame: not implemented\n");
3400 long do_sigreturn(CPUState
*env
)
3402 struct target_signal_frame
*frame
;
3403 abi_ulong frame_addr
;
3404 target_sigset_t target_set
;
3408 frame_addr
= env
->regs
[R_SP
];
3409 /* Make sure the guest isn't playing games. */
3410 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 1))
3413 /* Restore blocked signals */
3414 if (__get_user(target_set
.sig
[0], &frame
->sc
.oldmask
))
3416 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
3417 if (__get_user(target_set
.sig
[i
], &frame
->extramask
[i
- 1]))
3420 target_to_host_sigset_internal(&set
, &target_set
);
3421 sigprocmask(SIG_SETMASK
, &set
, NULL
);
3423 restore_sigcontext(&frame
->sc
, env
);
3424 unlock_user_struct(frame
, frame_addr
, 0);
3425 return env
->regs
[10];
3427 unlock_user_struct(frame
, frame_addr
, 0);
3428 force_sig(TARGET_SIGSEGV
);
3431 long do_rt_sigreturn(CPUState
*env
)
3433 fprintf(stderr
, "CRIS do_rt_sigreturn: not implemented\n");
3434 return -TARGET_ENOSYS
;
3437 #elif defined(TARGET_PPC) && !defined(TARGET_PPC64)
3439 /* FIXME: Many of the structures are defined for both PPC and PPC64, but
3440 the signal handling is different enough that we haven't implemented
3441 support for PPC64 yet. Hence the restriction above.
3443 There are various #if'd blocks for code for TARGET_PPC64. These
3444 blocks should go away so that we can successfully run 32-bit and
3445 64-bit binaries on a QEMU configured for PPC64. */
3447 /* Size of dummy stack frame allocated when calling signal handler.
3448 See arch/powerpc/include/asm/ptrace.h. */
3449 #if defined(TARGET_PPC64)
3450 #define SIGNAL_FRAMESIZE 128
3452 #define SIGNAL_FRAMESIZE 64
3455 /* See arch/powerpc/include/asm/sigcontext.h. */
3456 struct target_sigcontext
{
3457 target_ulong _unused
[4];
3459 #if defined(TARGET_PPC64)
3462 target_ulong handler
;
3463 target_ulong oldmask
;
3464 target_ulong regs
; /* struct pt_regs __user * */
3465 /* TODO: PPC64 includes extra bits here. */
3468 /* Indices for target_mcontext.mc_gregs, below.
3469 See arch/powerpc/include/asm/ptrace.h for details. */
3505 TARGET_PT_ORIG_R3
= 34,
3510 /* Yes, there are two registers with #39. One is 64-bit only. */
3512 TARGET_PT_SOFTE
= 39,
3513 TARGET_PT_TRAP
= 40,
3515 TARGET_PT_DSISR
= 42,
3516 TARGET_PT_RESULT
= 43,
3517 TARGET_PT_REGS_COUNT
= 44
3520 /* See arch/powerpc/include/asm/ucontext.h. Only used for 32-bit PPC;
3521 on 64-bit PPC, sigcontext and mcontext are one and the same. */
3522 struct target_mcontext
{
3523 target_ulong mc_gregs
[48];
3524 /* Includes fpscr. */
3525 uint64_t mc_fregs
[33];
3526 target_ulong mc_pad
[2];
3527 /* We need to handle Altivec and SPE at the same time, which no
3528 kernel needs to do. Fortunately, the kernel defines this bit to
3529 be Altivec-register-large all the time, rather than trying to
3530 twiddle it based on the specific platform. */
3532 /* SPE vector registers. One extra for SPEFSCR. */
3534 /* Altivec vector registers. The packing of VSCR and VRSAVE
3535 varies depending on whether we're PPC64 or not: PPC64 splits
3536 them apart; PPC32 stuffs them together. */
3537 #if defined(TARGET_PPC64)
3542 ppc_avr_t altivec
[NVRREG
];
3544 } mc_vregs
__attribute__((__aligned__(16)));
3547 struct target_ucontext
{
3548 target_ulong uc_flags
;
3549 target_ulong uc_link
; /* struct ucontext __user * */
3550 struct target_sigaltstack uc_stack
;
3551 #if !defined(TARGET_PPC64)
3553 target_ulong uc_regs
; /* struct mcontext __user *
3554 points to uc_mcontext field */
3556 target_sigset_t uc_sigmask
;
3557 #if defined(TARGET_PPC64)
3558 target_sigset_t unused
[15]; /* Allow for uc_sigmask growth */
3559 struct target_sigcontext uc_mcontext
;
3561 int32_t uc_maskext
[30];
3563 struct target_mcontext uc_mcontext
;
3567 /* See arch/powerpc/kernel/signal_32.c. */
3568 struct target_sigframe
{
3569 struct target_sigcontext sctx
;
3570 struct target_mcontext mctx
;
3574 struct target_rt_sigframe
{
3575 struct target_siginfo info
;
3576 struct target_ucontext uc
;
3580 /* We use the mc_pad field for the signal return trampoline. */
3581 #define tramp mc_pad
3583 /* See arch/powerpc/kernel/signal.c. */
3584 static target_ulong
get_sigframe(struct target_sigaction
*ka
,
3588 target_ulong oldsp
, newsp
;
3590 oldsp
= env
->gpr
[1];
3592 if ((ka
->sa_flags
& TARGET_SA_ONSTACK
) &&
3593 (sas_ss_flags(oldsp
))) {
3594 oldsp
= (target_sigaltstack_used
.ss_sp
3595 + target_sigaltstack_used
.ss_size
);
3598 newsp
= (oldsp
- frame_size
) & ~0xFUL
;
3603 static int save_user_regs(CPUState
*env
, struct target_mcontext
*frame
,
3606 target_ulong msr
= env
->msr
;
3608 target_ulong ccr
= 0;
3610 /* In general, the kernel attempts to be intelligent about what it
3611 needs to save for Altivec/FP/SPE registers. We don't care that
3612 much, so we just go ahead and save everything. */
3614 /* Save general registers. */
3615 for (i
= 0; i
< ARRAY_SIZE(env
->gpr
); i
++) {
3616 if (__put_user(env
->gpr
[i
], &frame
->mc_gregs
[i
])) {
3620 if (__put_user(env
->nip
, &frame
->mc_gregs
[TARGET_PT_NIP
])
3621 || __put_user(env
->ctr
, &frame
->mc_gregs
[TARGET_PT_CTR
])
3622 || __put_user(env
->lr
, &frame
->mc_gregs
[TARGET_PT_LNK
])
3623 || __put_user(env
->xer
, &frame
->mc_gregs
[TARGET_PT_XER
]))
3626 for (i
= 0; i
< ARRAY_SIZE(env
->crf
); i
++) {
3627 ccr
|= env
->crf
[i
] << (32 - ((i
+ 1) * 4));
3629 if (__put_user(ccr
, &frame
->mc_gregs
[TARGET_PT_CCR
]))
3632 /* Save Altivec registers if necessary. */
3633 if (env
->insns_flags
& PPC_ALTIVEC
) {
3634 for (i
= 0; i
< ARRAY_SIZE(env
->avr
); i
++) {
3635 ppc_avr_t
*avr
= &env
->avr
[i
];
3636 ppc_avr_t
*vreg
= &frame
->mc_vregs
.altivec
[i
];
3638 if (__put_user(avr
->u64
[0], &vreg
->u64
[0]) ||
3639 __put_user(avr
->u64
[1], &vreg
->u64
[1])) {
3643 /* Set MSR_VR in the saved MSR value to indicate that
3644 frame->mc_vregs contains valid data. */
3646 if (__put_user((uint32_t)env
->spr
[SPR_VRSAVE
],
3647 &frame
->mc_vregs
.altivec
[32].u32
[3]))
3651 /* Save floating point registers. */
3652 if (env
->insns_flags
& PPC_FLOAT
) {
3653 for (i
= 0; i
< ARRAY_SIZE(env
->fpr
); i
++) {
3654 if (__put_user(env
->fpr
[i
], &frame
->mc_fregs
[i
])) {
3658 if (__put_user((uint64_t) env
->fpscr
, &frame
->mc_fregs
[32]))
3662 /* Save SPE registers. The kernel only saves the high half. */
3663 if (env
->insns_flags
& PPC_SPE
) {
3664 #if defined(TARGET_PPC64)
3665 for (i
= 0; i
< ARRAY_SIZE(env
->gpr
); i
++) {
3666 if (__put_user(env
->gpr
[i
] >> 32, &frame
->mc_vregs
.spe
[i
])) {
3671 for (i
= 0; i
< ARRAY_SIZE(env
->gprh
); i
++) {
3672 if (__put_user(env
->gprh
[i
], &frame
->mc_vregs
.spe
[i
])) {
3677 /* Set MSR_SPE in the saved MSR value to indicate that
3678 frame->mc_vregs contains valid data. */
3680 if (__put_user(env
->spe_fscr
, &frame
->mc_vregs
.spe
[32]))
3685 if (__put_user(msr
, &frame
->mc_gregs
[TARGET_PT_MSR
]))
3688 /* Set up the sigreturn trampoline: li r0,sigret; sc. */
3690 if (__put_user(0x38000000UL
| sigret
, &frame
->tramp
[0]) ||
3691 __put_user(0x44000002UL
, &frame
->tramp
[1])) {
3699 static int restore_user_regs(CPUState
*env
,
3700 struct target_mcontext
*frame
, int sig
)
3702 target_ulong save_r2
= 0;
3709 save_r2
= env
->gpr
[2];
3712 /* Restore general registers. */
3713 for (i
= 0; i
< ARRAY_SIZE(env
->gpr
); i
++) {
3714 if (__get_user(env
->gpr
[i
], &frame
->mc_gregs
[i
])) {
3718 if (__get_user(env
->nip
, &frame
->mc_gregs
[TARGET_PT_NIP
])
3719 || __get_user(env
->ctr
, &frame
->mc_gregs
[TARGET_PT_CTR
])
3720 || __get_user(env
->lr
, &frame
->mc_gregs
[TARGET_PT_LNK
])
3721 || __get_user(env
->xer
, &frame
->mc_gregs
[TARGET_PT_XER
]))
3723 if (__get_user(ccr
, &frame
->mc_gregs
[TARGET_PT_CCR
]))
3726 for (i
= 0; i
< ARRAY_SIZE(env
->crf
); i
++) {
3727 env
->crf
[i
] = (ccr
>> (32 - ((i
+ 1) * 4))) & 0xf;
3731 env
->gpr
[2] = save_r2
;
3734 if (__get_user(msr
, &frame
->mc_gregs
[TARGET_PT_MSR
]))
3737 /* If doing signal return, restore the previous little-endian mode. */
3739 env
->msr
= (env
->msr
& ~MSR_LE
) | (msr
& MSR_LE
);
3741 /* Restore Altivec registers if necessary. */
3742 if (env
->insns_flags
& PPC_ALTIVEC
) {
3743 for (i
= 0; i
< ARRAY_SIZE(env
->avr
); i
++) {
3744 ppc_avr_t
*avr
= &env
->avr
[i
];
3745 ppc_avr_t
*vreg
= &frame
->mc_vregs
.altivec
[i
];
3747 if (__get_user(avr
->u64
[0], &vreg
->u64
[0]) ||
3748 __get_user(avr
->u64
[1], &vreg
->u64
[1])) {
3752 /* Set MSR_VEC in the saved MSR value to indicate that
3753 frame->mc_vregs contains valid data. */
3754 if (__get_user(env
->spr
[SPR_VRSAVE
],
3755 (target_ulong
*)(&frame
->mc_vregs
.altivec
[32].u32
[3])))
3759 /* Restore floating point registers. */
3760 if (env
->insns_flags
& PPC_FLOAT
) {
3762 for (i
= 0; i
< ARRAY_SIZE(env
->fpr
); i
++) {
3763 if (__get_user(env
->fpr
[i
], &frame
->mc_fregs
[i
])) {
3767 if (__get_user(fpscr
, &frame
->mc_fregs
[32]))
3769 env
->fpscr
= (uint32_t) fpscr
;
3772 /* Save SPE registers. The kernel only saves the high half. */
3773 if (env
->insns_flags
& PPC_SPE
) {
3774 #if defined(TARGET_PPC64)
3775 for (i
= 0; i
< ARRAY_SIZE(env
->gpr
); i
++) {
3778 if (__get_user(hi
, &frame
->mc_vregs
.spe
[i
])) {
3781 env
->gpr
[i
] = ((uint64_t)hi
<< 32) | ((uint32_t) env
->gpr
[i
]);
3784 for (i
= 0; i
< ARRAY_SIZE(env
->gprh
); i
++) {
3785 if (__get_user(env
->gprh
[i
], &frame
->mc_vregs
.spe
[i
])) {
3790 if (__get_user(env
->spe_fscr
, &frame
->mc_vregs
.spe
[32]))
3797 static void setup_frame(int sig
, struct target_sigaction
*ka
,
3798 target_sigset_t
*set
, CPUState
*env
)
3800 struct target_sigframe
*frame
;
3801 struct target_sigcontext
*sc
;
3802 target_ulong frame_addr
, newsp
;
3806 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
3807 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 1))
3811 signal
= current_exec_domain_sig(sig
);
3813 err
|= __put_user(h2g(ka
->_sa_handler
), &sc
->handler
);
3814 err
|= __put_user(set
->sig
[0], &sc
->oldmask
);
3815 #if defined(TARGET_PPC64)
3816 err
|= __put_user(set
->sig
[0] >> 32, &sc
->_unused
[3]);
3818 err
|= __put_user(set
->sig
[1], &sc
->_unused
[3]);
3820 err
|= __put_user(h2g(&frame
->mctx
), &sc
->regs
);
3821 err
|= __put_user(sig
, &sc
->signal
);
3823 /* Save user regs. */
3824 err
|= save_user_regs(env
, &frame
->mctx
, TARGET_NR_sigreturn
);
3826 /* The kernel checks for the presence of a VDSO here. We don't
3827 emulate a vdso, so use a sigreturn system call. */
3828 env
->lr
= (target_ulong
) h2g(frame
->mctx
.tramp
);
3830 /* Turn off all fp exceptions. */
3833 /* Create a stack frame for the caller of the handler. */
3834 newsp
= frame_addr
- SIGNAL_FRAMESIZE
;
3835 err
|= __put_user(env
->gpr
[1], (target_ulong
*)(uintptr_t) newsp
);
3840 /* Set up registers for signal handler. */
3841 env
->gpr
[1] = newsp
;
3842 env
->gpr
[3] = signal
;
3843 env
->gpr
[4] = (target_ulong
) h2g(sc
);
3844 env
->nip
= (target_ulong
) ka
->_sa_handler
;
3845 /* Signal handlers are entered in big-endian mode. */
3846 env
->msr
&= ~MSR_LE
;
3848 unlock_user_struct(frame
, frame_addr
, 1);
3852 unlock_user_struct(frame
, frame_addr
, 1);
3854 fprintf (logfile
, "segfaulting from setup_frame\n");
3858 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
3859 target_siginfo_t
*info
,
3860 target_sigset_t
*set
, CPUState
*env
)
3862 struct target_rt_sigframe
*rt_sf
;
3863 struct target_mcontext
*frame
;
3864 target_ulong rt_sf_addr
, newsp
= 0;
3868 rt_sf_addr
= get_sigframe(ka
, env
, sizeof(*rt_sf
));
3869 if (!lock_user_struct(VERIFY_WRITE
, rt_sf
, rt_sf_addr
, 1))
3872 signal
= current_exec_domain_sig(sig
);
3874 err
|= copy_siginfo_to_user(&rt_sf
->info
, info
);
3876 err
|= __put_user(0, &rt_sf
->uc
.uc_flags
);
3877 err
|= __put_user(0, &rt_sf
->uc
.uc_link
);
3878 err
|= __put_user((target_ulong
)target_sigaltstack_used
.ss_sp
,
3879 &rt_sf
->uc
.uc_stack
.ss_sp
);
3880 err
|= __put_user(sas_ss_flags(env
->gpr
[1]),
3881 &rt_sf
->uc
.uc_stack
.ss_flags
);
3882 err
|= __put_user(target_sigaltstack_used
.ss_size
,
3883 &rt_sf
->uc
.uc_stack
.ss_size
);
3884 err
|= __put_user(h2g (&rt_sf
->uc
.uc_mcontext
),
3885 &rt_sf
->uc
.uc_regs
);
3886 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
3887 err
|= __put_user(set
->sig
[i
], &rt_sf
->uc
.uc_sigmask
.sig
[i
]);
3890 frame
= &rt_sf
->uc
.uc_mcontext
;
3891 err
|= save_user_regs(env
, frame
, TARGET_NR_rt_sigreturn
);
3893 /* The kernel checks for the presence of a VDSO here. We don't
3894 emulate a vdso, so use a sigreturn system call. */
3895 env
->lr
= (target_ulong
) h2g(frame
->tramp
);
3897 /* Turn off all fp exceptions. */
3900 /* Create a stack frame for the caller of the handler. */
3901 newsp
= rt_sf_addr
- (SIGNAL_FRAMESIZE
+ 16);
3902 err
|= __put_user(env
->gpr
[1], (target_ulong
*)(uintptr_t) newsp
);
3907 /* Set up registers for signal handler. */
3908 env
->gpr
[1] = newsp
;
3909 env
->gpr
[3] = (target_ulong
) signal
;
3910 env
->gpr
[4] = (target_ulong
) h2g(&rt_sf
->info
);
3911 env
->gpr
[5] = (target_ulong
) h2g(&rt_sf
->uc
);
3912 env
->gpr
[6] = (target_ulong
) h2g(rt_sf
);
3913 env
->nip
= (target_ulong
) ka
->_sa_handler
;
3914 /* Signal handlers are entered in big-endian mode. */
3915 env
->msr
&= ~MSR_LE
;
3917 unlock_user_struct(rt_sf
, rt_sf_addr
, 1);
3921 unlock_user_struct(rt_sf
, rt_sf_addr
, 1);
3923 fprintf (logfile
, "segfaulting from setup_rt_frame\n");
3928 long do_sigreturn(CPUState
*env
)
3930 struct target_sigcontext
*sc
= NULL
;
3931 struct target_mcontext
*sr
= NULL
;
3932 target_ulong sr_addr
, sc_addr
;
3934 target_sigset_t set
;
3936 sc_addr
= env
->gpr
[1] + SIGNAL_FRAMESIZE
;
3937 if (!lock_user_struct(VERIFY_READ
, sc
, sc_addr
, 1))
3940 #if defined(TARGET_PPC64)
3941 set
.sig
[0] = sc
->oldmask
+ ((long)(sc
->_unused
[3]) << 32);
3943 if(__get_user(set
.sig
[0], &sc
->oldmask
) ||
3944 __get_user(set
.sig
[1], &sc
->_unused
[3]))
3947 target_to_host_sigset_internal(&blocked
, &set
);
3948 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
3950 if (__get_user(sr_addr
, &sc
->regs
))
3952 if (!lock_user_struct(VERIFY_READ
, sr
, sr_addr
, 1))
3954 if (restore_user_regs(env
, sr
, 1))
3957 unlock_user_struct(sr
, sr_addr
, 1);
3958 unlock_user_struct(sc
, sc_addr
, 1);
3959 return -TARGET_QEMU_ESIGRETURN
;
3962 unlock_user_struct(sr
, sr_addr
, 1);
3963 unlock_user_struct(sc
, sc_addr
, 1);
3965 fprintf (logfile
, "segfaulting from do_sigreturn\n");
3970 /* See arch/powerpc/kernel/signal_32.c. */
3971 static int do_setcontext(struct target_ucontext
*ucp
, CPUState
*env
, int sig
)
3973 struct target_mcontext
*mcp
;
3974 target_ulong mcp_addr
;
3976 target_sigset_t set
;
3978 if (copy_from_user(&set
, h2g(ucp
) + offsetof(struct target_ucontext
, uc_sigmask
),
3982 #if defined(TARGET_PPC64)
3983 fprintf (stderr
, "do_setcontext: not implemented\n");
3986 if (__get_user(mcp_addr
, &ucp
->uc_regs
))
3989 if (!lock_user_struct(VERIFY_READ
, mcp
, mcp_addr
, 1))
3992 target_to_host_sigset_internal(&blocked
, &set
);
3993 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
3994 if (restore_user_regs(env
, mcp
, sig
))
3997 unlock_user_struct(mcp
, mcp_addr
, 1);
4001 unlock_user_struct(mcp
, mcp_addr
, 1);
4006 long do_rt_sigreturn(CPUState
*env
)
4008 struct target_rt_sigframe
*rt_sf
= NULL
;
4009 target_ulong rt_sf_addr
;
4011 rt_sf_addr
= env
->gpr
[1] + SIGNAL_FRAMESIZE
+ 16;
4012 if (!lock_user_struct(VERIFY_READ
, rt_sf
, rt_sf_addr
, 1))
4015 if (do_setcontext(&rt_sf
->uc
, env
, 1))
4018 do_sigaltstack(rt_sf_addr
4019 + offsetof(struct target_rt_sigframe
, uc
.uc_stack
),
4022 unlock_user_struct(rt_sf
, rt_sf_addr
, 1);
4023 return -TARGET_QEMU_ESIGRETURN
;
4026 unlock_user_struct(rt_sf
, rt_sf_addr
, 1);
4028 fprintf (logfile
, "segfaulting from do_rt_sigreturn\n");
4035 static void setup_frame(int sig
, struct target_sigaction
*ka
,
4036 target_sigset_t
*set
, CPUState
*env
)
4038 fprintf(stderr
, "setup_frame: not implemented\n");
4041 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
4042 target_siginfo_t
*info
,
4043 target_sigset_t
*set
, CPUState
*env
)
4045 fprintf(stderr
, "setup_rt_frame: not implemented\n");
4048 long do_sigreturn(CPUState
*env
)
4050 fprintf(stderr
, "do_sigreturn: not implemented\n");
4051 return -TARGET_ENOSYS
;
4054 long do_rt_sigreturn(CPUState
*env
)
4056 fprintf(stderr
, "do_rt_sigreturn: not implemented\n");
4057 return -TARGET_ENOSYS
;
4062 void process_pending_signals(CPUState
*cpu_env
)
4066 sigset_t set
, old_set
;
4067 target_sigset_t target_old_set
;
4068 struct emulated_sigtable
*k
;
4069 struct target_sigaction
*sa
;
4071 TaskState
*ts
= cpu_env
->opaque
;
4073 if (!ts
->signal_pending
)
4076 /* FIXME: This is not threadsafe. */
4078 for(sig
= 1; sig
<= TARGET_NSIG
; sig
++) {
4083 /* if no signal is pending, just return */
4084 ts
->signal_pending
= 0;
4089 fprintf(stderr
, "qemu: process signal %d\n", sig
);
4091 /* dequeue signal */
4097 sig
= gdb_handlesig (cpu_env
, sig
);
4100 handler
= TARGET_SIG_IGN
;
4102 sa
= &sigact_table
[sig
- 1];
4103 handler
= sa
->_sa_handler
;
4106 if (handler
== TARGET_SIG_DFL
) {
4107 /* default handler : ignore some signal. The other are job control or fatal */
4108 if (sig
== TARGET_SIGTSTP
|| sig
== TARGET_SIGTTIN
|| sig
== TARGET_SIGTTOU
) {
4109 kill(getpid(),SIGSTOP
);
4110 } else if (sig
!= TARGET_SIGCHLD
&&
4111 sig
!= TARGET_SIGURG
&&
4112 sig
!= TARGET_SIGWINCH
&&
4113 sig
!= TARGET_SIGCONT
) {
4116 } else if (handler
== TARGET_SIG_IGN
) {
4118 } else if (handler
== TARGET_SIG_ERR
) {
4121 /* compute the blocked signals during the handler execution */
4122 target_to_host_sigset(&set
, &sa
->sa_mask
);
4123 /* SA_NODEFER indicates that the current signal should not be
4124 blocked during the handler */
4125 if (!(sa
->sa_flags
& TARGET_SA_NODEFER
))
4126 sigaddset(&set
, target_to_host_signal(sig
));
4128 /* block signals in the handler using Linux */
4129 sigprocmask(SIG_BLOCK
, &set
, &old_set
);
4130 /* save the previous blocked signal state to restore it at the
4131 end of the signal execution (see do_sigreturn) */
4132 host_to_target_sigset_internal(&target_old_set
, &old_set
);
4134 /* if the CPU is in VM86 mode, we restore the 32 bit values */
4135 #if defined(TARGET_I386) && !defined(TARGET_X86_64)
4137 CPUX86State
*env
= cpu_env
;
4138 if (env
->eflags
& VM_MASK
)
4139 save_v86_state(env
);
4142 /* prepare the stack frame of the virtual CPU */
4143 if (sa
->sa_flags
& TARGET_SA_SIGINFO
)
4144 setup_rt_frame(sig
, sa
, &q
->info
, &target_old_set
, cpu_env
);
4146 setup_frame(sig
, sa
, &target_old_set
, cpu_env
);
4147 if (sa
->sa_flags
& TARGET_SA_RESETHAND
)
4148 sa
->_sa_handler
= TARGET_SIG_DFL
;
4151 free_sigqueue(cpu_env
, q
);