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, see <http://www.gnu.org/licenses/>.
26 #include <sys/ucontext.h>
27 #include <sys/resource.h>
30 #include "qemu-common.h"
31 #include "target_signal.h"
33 //#define DEBUG_SIGNAL
35 static struct target_sigaltstack target_sigaltstack_used
= {
38 .ss_flags
= TARGET_SS_DISABLE
,
41 static struct target_sigaction sigact_table
[TARGET_NSIG
];
43 static void host_signal_handler(int host_signum
, siginfo_t
*info
,
46 static uint8_t host_to_target_signal_table
[_NSIG
] = {
47 [SIGHUP
] = TARGET_SIGHUP
,
48 [SIGINT
] = TARGET_SIGINT
,
49 [SIGQUIT
] = TARGET_SIGQUIT
,
50 [SIGILL
] = TARGET_SIGILL
,
51 [SIGTRAP
] = TARGET_SIGTRAP
,
52 [SIGABRT
] = TARGET_SIGABRT
,
53 /* [SIGIOT] = TARGET_SIGIOT,*/
54 [SIGBUS
] = TARGET_SIGBUS
,
55 [SIGFPE
] = TARGET_SIGFPE
,
56 [SIGKILL
] = TARGET_SIGKILL
,
57 [SIGUSR1
] = TARGET_SIGUSR1
,
58 [SIGSEGV
] = TARGET_SIGSEGV
,
59 [SIGUSR2
] = TARGET_SIGUSR2
,
60 [SIGPIPE
] = TARGET_SIGPIPE
,
61 [SIGALRM
] = TARGET_SIGALRM
,
62 [SIGTERM
] = TARGET_SIGTERM
,
64 [SIGSTKFLT
] = TARGET_SIGSTKFLT
,
66 [SIGCHLD
] = TARGET_SIGCHLD
,
67 [SIGCONT
] = TARGET_SIGCONT
,
68 [SIGSTOP
] = TARGET_SIGSTOP
,
69 [SIGTSTP
] = TARGET_SIGTSTP
,
70 [SIGTTIN
] = TARGET_SIGTTIN
,
71 [SIGTTOU
] = TARGET_SIGTTOU
,
72 [SIGURG
] = TARGET_SIGURG
,
73 [SIGXCPU
] = TARGET_SIGXCPU
,
74 [SIGXFSZ
] = TARGET_SIGXFSZ
,
75 [SIGVTALRM
] = TARGET_SIGVTALRM
,
76 [SIGPROF
] = TARGET_SIGPROF
,
77 [SIGWINCH
] = TARGET_SIGWINCH
,
78 [SIGIO
] = TARGET_SIGIO
,
79 [SIGPWR
] = TARGET_SIGPWR
,
80 [SIGSYS
] = TARGET_SIGSYS
,
81 /* next signals stay the same */
82 /* Nasty hack: Reverse SIGRTMIN and SIGRTMAX to avoid overlap with
83 host libpthread signals. This assumes noone actually uses SIGRTMAX :-/
84 To fix this properly we need to do manual signal delivery multiplexed
85 over a single host signal. */
86 [__SIGRTMIN
] = __SIGRTMAX
,
87 [__SIGRTMAX
] = __SIGRTMIN
,
89 static uint8_t target_to_host_signal_table
[_NSIG
];
91 static inline int on_sig_stack(unsigned long sp
)
93 return (sp
- target_sigaltstack_used
.ss_sp
94 < target_sigaltstack_used
.ss_size
);
97 static inline int sas_ss_flags(unsigned long sp
)
99 return (target_sigaltstack_used
.ss_size
== 0 ? SS_DISABLE
100 : on_sig_stack(sp
) ? SS_ONSTACK
: 0);
103 int host_to_target_signal(int sig
)
107 return host_to_target_signal_table
[sig
];
110 int target_to_host_signal(int sig
)
114 return target_to_host_signal_table
[sig
];
117 static inline void target_sigemptyset(target_sigset_t
*set
)
119 memset(set
, 0, sizeof(*set
));
122 static inline void target_sigaddset(target_sigset_t
*set
, int signum
)
125 abi_ulong mask
= (abi_ulong
)1 << (signum
% TARGET_NSIG_BPW
);
126 set
->sig
[signum
/ TARGET_NSIG_BPW
] |= mask
;
129 static inline int target_sigismember(const target_sigset_t
*set
, int signum
)
132 abi_ulong mask
= (abi_ulong
)1 << (signum
% TARGET_NSIG_BPW
);
133 return ((set
->sig
[signum
/ TARGET_NSIG_BPW
] & mask
) != 0);
136 static void host_to_target_sigset_internal(target_sigset_t
*d
,
140 target_sigemptyset(d
);
141 for (i
= 1; i
<= TARGET_NSIG
; i
++) {
142 if (sigismember(s
, i
)) {
143 target_sigaddset(d
, host_to_target_signal(i
));
148 void host_to_target_sigset(target_sigset_t
*d
, const sigset_t
*s
)
153 host_to_target_sigset_internal(&d1
, s
);
154 for(i
= 0;i
< TARGET_NSIG_WORDS
; i
++)
155 d
->sig
[i
] = tswapl(d1
.sig
[i
]);
158 static void target_to_host_sigset_internal(sigset_t
*d
,
159 const target_sigset_t
*s
)
163 for (i
= 1; i
<= TARGET_NSIG
; i
++) {
164 if (target_sigismember(s
, i
)) {
165 sigaddset(d
, target_to_host_signal(i
));
170 void target_to_host_sigset(sigset_t
*d
, const target_sigset_t
*s
)
175 for(i
= 0;i
< TARGET_NSIG_WORDS
; i
++)
176 s1
.sig
[i
] = tswapl(s
->sig
[i
]);
177 target_to_host_sigset_internal(d
, &s1
);
180 void host_to_target_old_sigset(abi_ulong
*old_sigset
,
181 const sigset_t
*sigset
)
184 host_to_target_sigset(&d
, sigset
);
185 *old_sigset
= d
.sig
[0];
188 void target_to_host_old_sigset(sigset_t
*sigset
,
189 const abi_ulong
*old_sigset
)
194 d
.sig
[0] = *old_sigset
;
195 for(i
= 1;i
< TARGET_NSIG_WORDS
; i
++)
197 target_to_host_sigset(sigset
, &d
);
200 /* siginfo conversion */
202 static inline void host_to_target_siginfo_noswap(target_siginfo_t
*tinfo
,
203 const siginfo_t
*info
)
206 sig
= host_to_target_signal(info
->si_signo
);
207 tinfo
->si_signo
= sig
;
209 tinfo
->si_code
= info
->si_code
;
210 if (sig
== SIGILL
|| sig
== SIGFPE
|| sig
== SIGSEGV
||
211 sig
== SIGBUS
|| sig
== SIGTRAP
) {
212 /* should never come here, but who knows. The information for
213 the target is irrelevant */
214 tinfo
->_sifields
._sigfault
._addr
= 0;
215 } else if (sig
== SIGIO
) {
216 tinfo
->_sifields
._sigpoll
._fd
= info
->si_fd
;
217 } else if (sig
>= TARGET_SIGRTMIN
) {
218 tinfo
->_sifields
._rt
._pid
= info
->si_pid
;
219 tinfo
->_sifields
._rt
._uid
= info
->si_uid
;
220 /* XXX: potential problem if 64 bit */
221 tinfo
->_sifields
._rt
._sigval
.sival_ptr
=
222 (abi_ulong
)(unsigned long)info
->si_value
.sival_ptr
;
226 static void tswap_siginfo(target_siginfo_t
*tinfo
,
227 const target_siginfo_t
*info
)
230 sig
= info
->si_signo
;
231 tinfo
->si_signo
= tswap32(sig
);
232 tinfo
->si_errno
= tswap32(info
->si_errno
);
233 tinfo
->si_code
= tswap32(info
->si_code
);
234 if (sig
== SIGILL
|| sig
== SIGFPE
|| sig
== SIGSEGV
||
235 sig
== SIGBUS
|| sig
== SIGTRAP
) {
236 tinfo
->_sifields
._sigfault
._addr
=
237 tswapl(info
->_sifields
._sigfault
._addr
);
238 } else if (sig
== SIGIO
) {
239 tinfo
->_sifields
._sigpoll
._fd
= tswap32(info
->_sifields
._sigpoll
._fd
);
240 } else if (sig
>= TARGET_SIGRTMIN
) {
241 tinfo
->_sifields
._rt
._pid
= tswap32(info
->_sifields
._rt
._pid
);
242 tinfo
->_sifields
._rt
._uid
= tswap32(info
->_sifields
._rt
._uid
);
243 tinfo
->_sifields
._rt
._sigval
.sival_ptr
=
244 tswapl(info
->_sifields
._rt
._sigval
.sival_ptr
);
249 void host_to_target_siginfo(target_siginfo_t
*tinfo
, const siginfo_t
*info
)
251 host_to_target_siginfo_noswap(tinfo
, info
);
252 tswap_siginfo(tinfo
, tinfo
);
255 /* XXX: we support only POSIX RT signals are used. */
256 /* XXX: find a solution for 64 bit (additional malloced data is needed) */
257 void target_to_host_siginfo(siginfo_t
*info
, const target_siginfo_t
*tinfo
)
259 info
->si_signo
= tswap32(tinfo
->si_signo
);
260 info
->si_errno
= tswap32(tinfo
->si_errno
);
261 info
->si_code
= tswap32(tinfo
->si_code
);
262 info
->si_pid
= tswap32(tinfo
->_sifields
._rt
._pid
);
263 info
->si_uid
= tswap32(tinfo
->_sifields
._rt
._uid
);
264 info
->si_value
.sival_ptr
=
265 (void *)(long)tswapl(tinfo
->_sifields
._rt
._sigval
.sival_ptr
);
268 static int fatal_signal (int sig
)
273 case TARGET_SIGWINCH
:
274 /* Ignored by default. */
281 /* Job control signals. */
288 /* returns 1 if given signal should dump core if not handled */
289 static int core_dump_signal(int sig
)
305 void signal_init(void)
307 struct sigaction act
;
308 struct sigaction oact
;
312 /* generate signal conversion tables */
313 for(i
= 1; i
< _NSIG
; i
++) {
314 if (host_to_target_signal_table
[i
] == 0)
315 host_to_target_signal_table
[i
] = i
;
317 for(i
= 1; i
< _NSIG
; i
++) {
318 j
= host_to_target_signal_table
[i
];
319 target_to_host_signal_table
[j
] = i
;
322 /* set all host signal handlers. ALL signals are blocked during
323 the handlers to serialize them. */
324 memset(sigact_table
, 0, sizeof(sigact_table
));
326 sigfillset(&act
.sa_mask
);
327 act
.sa_flags
= SA_SIGINFO
;
328 act
.sa_sigaction
= host_signal_handler
;
329 for(i
= 1; i
<= TARGET_NSIG
; i
++) {
330 host_sig
= target_to_host_signal(i
);
331 sigaction(host_sig
, NULL
, &oact
);
332 if (oact
.sa_sigaction
== (void *)SIG_IGN
) {
333 sigact_table
[i
- 1]._sa_handler
= TARGET_SIG_IGN
;
334 } else if (oact
.sa_sigaction
== (void *)SIG_DFL
) {
335 sigact_table
[i
- 1]._sa_handler
= TARGET_SIG_DFL
;
337 /* If there's already a handler installed then something has
338 gone horribly wrong, so don't even try to handle that case. */
339 /* Install some handlers for our own use. We need at least
340 SIGSEGV and SIGBUS, to detect exceptions. We can not just
341 trap all signals because it affects syscall interrupt
342 behavior. But do trap all default-fatal signals. */
343 if (fatal_signal (i
))
344 sigaction(host_sig
, &act
, NULL
);
348 /* signal queue handling */
350 static inline struct sigqueue
*alloc_sigqueue(CPUState
*env
)
352 TaskState
*ts
= env
->opaque
;
353 struct sigqueue
*q
= ts
->first_free
;
356 ts
->first_free
= q
->next
;
360 static inline void free_sigqueue(CPUState
*env
, struct sigqueue
*q
)
362 TaskState
*ts
= env
->opaque
;
363 q
->next
= ts
->first_free
;
367 /* abort execution with signal */
368 static void QEMU_NORETURN
force_sig(int target_sig
)
370 TaskState
*ts
= (TaskState
*)thread_env
->opaque
;
371 int host_sig
, core_dumped
= 0;
372 struct sigaction act
;
373 host_sig
= target_to_host_signal(target_sig
);
374 gdb_signalled(thread_env
, target_sig
);
376 /* dump core if supported by target binary format */
377 if (core_dump_signal(target_sig
) && (ts
->bprm
->core_dump
!= NULL
)) {
380 ((*ts
->bprm
->core_dump
)(target_sig
, thread_env
) == 0);
383 /* we already dumped the core of target process, we don't want
384 * a coredump of qemu itself */
385 struct rlimit nodump
;
386 getrlimit(RLIMIT_CORE
, &nodump
);
388 setrlimit(RLIMIT_CORE
, &nodump
);
389 (void) fprintf(stderr
, "qemu: uncaught target signal %d (%s) - %s\n",
390 target_sig
, strsignal(host_sig
), "core dumped" );
393 /* The proper exit code for dying from an uncaught signal is
394 * -<signal>. The kernel doesn't allow exit() or _exit() to pass
395 * a negative value. To get the proper exit code we need to
396 * actually die from an uncaught signal. Here the default signal
397 * handler is installed, we send ourself a signal and we wait for
399 sigfillset(&act
.sa_mask
);
400 act
.sa_handler
= SIG_DFL
;
401 sigaction(host_sig
, &act
, NULL
);
403 /* For some reason raise(host_sig) doesn't send the signal when
404 * statically linked on x86-64. */
405 kill(getpid(), host_sig
);
407 /* Make sure the signal isn't masked (just reuse the mask inside
409 sigdelset(&act
.sa_mask
, host_sig
);
410 sigsuspend(&act
.sa_mask
);
416 /* queue a signal so that it will be send to the virtual CPU as soon
418 int queue_signal(CPUState
*env
, int sig
, target_siginfo_t
*info
)
420 TaskState
*ts
= env
->opaque
;
421 struct emulated_sigtable
*k
;
422 struct sigqueue
*q
, **pq
;
426 #if defined(DEBUG_SIGNAL)
427 fprintf(stderr
, "queue_signal: sig=%d\n",
430 k
= &ts
->sigtab
[sig
- 1];
431 queue
= gdb_queuesig ();
432 handler
= sigact_table
[sig
- 1]._sa_handler
;
433 if (!queue
&& handler
== TARGET_SIG_DFL
) {
434 if (sig
== TARGET_SIGTSTP
|| sig
== TARGET_SIGTTIN
|| sig
== TARGET_SIGTTOU
) {
435 kill(getpid(),SIGSTOP
);
438 /* default handler : ignore some signal. The other are fatal */
439 if (sig
!= TARGET_SIGCHLD
&&
440 sig
!= TARGET_SIGURG
&&
441 sig
!= TARGET_SIGWINCH
&&
442 sig
!= TARGET_SIGCONT
) {
445 return 0; /* indicate ignored */
447 } else if (!queue
&& handler
== TARGET_SIG_IGN
) {
450 } else if (!queue
&& handler
== TARGET_SIG_ERR
) {
454 if (sig
< TARGET_SIGRTMIN
) {
455 /* if non real time signal, we queue exactly one signal */
465 q
= alloc_sigqueue(env
);
476 /* signal that a new signal is pending */
477 ts
->signal_pending
= 1;
478 return 1; /* indicates that the signal was queued */
482 static void host_signal_handler(int host_signum
, siginfo_t
*info
,
486 target_siginfo_t tinfo
;
488 /* the CPU emulator uses some host signals to detect exceptions,
489 we forward to it some signals */
490 if ((host_signum
== SIGSEGV
|| host_signum
== SIGBUS
)
491 && info
->si_code
> 0) {
492 if (cpu_signal_handler(host_signum
, info
, puc
))
496 /* get target signal number */
497 sig
= host_to_target_signal(host_signum
);
498 if (sig
< 1 || sig
> TARGET_NSIG
)
500 #if defined(DEBUG_SIGNAL)
501 fprintf(stderr
, "qemu: got signal %d\n", sig
);
503 host_to_target_siginfo_noswap(&tinfo
, info
);
504 if (queue_signal(thread_env
, sig
, &tinfo
) == 1) {
505 /* interrupt the virtual CPU as soon as possible */
506 cpu_exit(thread_env
);
510 /* do_sigaltstack() returns target values and errnos. */
511 /* compare linux/kernel/signal.c:do_sigaltstack() */
512 abi_long
do_sigaltstack(abi_ulong uss_addr
, abi_ulong uoss_addr
, abi_ulong sp
)
515 struct target_sigaltstack oss
;
517 /* XXX: test errors */
520 __put_user(target_sigaltstack_used
.ss_sp
, &oss
.ss_sp
);
521 __put_user(target_sigaltstack_used
.ss_size
, &oss
.ss_size
);
522 __put_user(sas_ss_flags(sp
), &oss
.ss_flags
);
527 struct target_sigaltstack
*uss
;
528 struct target_sigaltstack ss
;
530 ret
= -TARGET_EFAULT
;
531 if (!lock_user_struct(VERIFY_READ
, uss
, uss_addr
, 1)
532 || __get_user(ss
.ss_sp
, &uss
->ss_sp
)
533 || __get_user(ss
.ss_size
, &uss
->ss_size
)
534 || __get_user(ss
.ss_flags
, &uss
->ss_flags
))
536 unlock_user_struct(uss
, uss_addr
, 0);
539 if (on_sig_stack(sp
))
542 ret
= -TARGET_EINVAL
;
543 if (ss
.ss_flags
!= TARGET_SS_DISABLE
544 && ss
.ss_flags
!= TARGET_SS_ONSTACK
548 if (ss
.ss_flags
== TARGET_SS_DISABLE
) {
552 ret
= -TARGET_ENOMEM
;
553 if (ss
.ss_size
< MINSIGSTKSZ
)
557 target_sigaltstack_used
.ss_sp
= ss
.ss_sp
;
558 target_sigaltstack_used
.ss_size
= ss
.ss_size
;
562 ret
= -TARGET_EFAULT
;
563 if (copy_to_user(uoss_addr
, &oss
, sizeof(oss
)))
572 /* do_sigaction() return host values and errnos */
573 int do_sigaction(int sig
, const struct target_sigaction
*act
,
574 struct target_sigaction
*oact
)
576 struct target_sigaction
*k
;
577 struct sigaction act1
;
581 if (sig
< 1 || sig
> TARGET_NSIG
|| sig
== TARGET_SIGKILL
|| sig
== TARGET_SIGSTOP
)
583 k
= &sigact_table
[sig
- 1];
584 #if defined(DEBUG_SIGNAL)
585 fprintf(stderr
, "sigaction sig=%d act=0x%p, oact=0x%p\n",
589 oact
->_sa_handler
= tswapl(k
->_sa_handler
);
590 oact
->sa_flags
= tswapl(k
->sa_flags
);
591 #if !defined(TARGET_MIPS)
592 oact
->sa_restorer
= tswapl(k
->sa_restorer
);
594 oact
->sa_mask
= k
->sa_mask
;
597 /* FIXME: This is not threadsafe. */
598 k
->_sa_handler
= tswapl(act
->_sa_handler
);
599 k
->sa_flags
= tswapl(act
->sa_flags
);
600 #if !defined(TARGET_MIPS)
601 k
->sa_restorer
= tswapl(act
->sa_restorer
);
603 k
->sa_mask
= act
->sa_mask
;
605 /* we update the host linux signal state */
606 host_sig
= target_to_host_signal(sig
);
607 if (host_sig
!= SIGSEGV
&& host_sig
!= SIGBUS
) {
608 sigfillset(&act1
.sa_mask
);
609 act1
.sa_flags
= SA_SIGINFO
;
610 if (k
->sa_flags
& TARGET_SA_RESTART
)
611 act1
.sa_flags
|= SA_RESTART
;
612 /* NOTE: it is important to update the host kernel signal
613 ignore state to avoid getting unexpected interrupted
615 if (k
->_sa_handler
== TARGET_SIG_IGN
) {
616 act1
.sa_sigaction
= (void *)SIG_IGN
;
617 } else if (k
->_sa_handler
== TARGET_SIG_DFL
) {
618 if (fatal_signal (sig
))
619 act1
.sa_sigaction
= host_signal_handler
;
621 act1
.sa_sigaction
= (void *)SIG_DFL
;
623 act1
.sa_sigaction
= host_signal_handler
;
625 ret
= sigaction(host_sig
, &act1
, NULL
);
631 static inline int copy_siginfo_to_user(target_siginfo_t
*tinfo
,
632 const target_siginfo_t
*info
)
634 tswap_siginfo(tinfo
, info
);
638 static inline int current_exec_domain_sig(int sig
)
640 return /* current->exec_domain && current->exec_domain->signal_invmap
641 && sig < 32 ? current->exec_domain->signal_invmap[sig] : */ sig
;
644 #if defined(TARGET_I386) && TARGET_ABI_BITS == 32
646 /* from the Linux kernel */
648 struct target_fpreg
{
649 uint16_t significand
[4];
653 struct target_fpxreg
{
654 uint16_t significand
[4];
659 struct target_xmmreg
{
660 abi_ulong element
[4];
663 struct target_fpstate
{
664 /* Regular FPU environment */
672 struct target_fpreg _st
[8];
674 uint16_t magic
; /* 0xffff = regular FPU data only */
676 /* FXSR FPU environment */
677 abi_ulong _fxsr_env
[6]; /* FXSR FPU env is ignored */
680 struct target_fpxreg _fxsr_st
[8]; /* FXSR FPU reg data is ignored */
681 struct target_xmmreg _xmm
[8];
682 abi_ulong padding
[56];
685 #define X86_FXSR_MAGIC 0x0000
687 struct target_sigcontext
{
705 abi_ulong esp_at_signal
;
707 abi_ulong fpstate
; /* pointer */
712 struct target_ucontext
{
715 target_stack_t tuc_stack
;
716 struct target_sigcontext tuc_mcontext
;
717 target_sigset_t tuc_sigmask
; /* mask last for extensibility */
724 struct target_sigcontext sc
;
725 struct target_fpstate fpstate
;
726 abi_ulong extramask
[TARGET_NSIG_WORDS
-1];
736 struct target_siginfo info
;
737 struct target_ucontext uc
;
738 struct target_fpstate fpstate
;
743 * Set up a signal frame.
746 /* XXX: save x87 state */
748 setup_sigcontext(struct target_sigcontext
*sc
, struct target_fpstate
*fpstate
,
749 CPUX86State
*env
, abi_ulong mask
, abi_ulong fpstate_addr
)
754 /* already locked in setup_frame() */
755 err
|= __put_user(env
->segs
[R_GS
].selector
, (unsigned int *)&sc
->gs
);
756 err
|= __put_user(env
->segs
[R_FS
].selector
, (unsigned int *)&sc
->fs
);
757 err
|= __put_user(env
->segs
[R_ES
].selector
, (unsigned int *)&sc
->es
);
758 err
|= __put_user(env
->segs
[R_DS
].selector
, (unsigned int *)&sc
->ds
);
759 err
|= __put_user(env
->regs
[R_EDI
], &sc
->edi
);
760 err
|= __put_user(env
->regs
[R_ESI
], &sc
->esi
);
761 err
|= __put_user(env
->regs
[R_EBP
], &sc
->ebp
);
762 err
|= __put_user(env
->regs
[R_ESP
], &sc
->esp
);
763 err
|= __put_user(env
->regs
[R_EBX
], &sc
->ebx
);
764 err
|= __put_user(env
->regs
[R_EDX
], &sc
->edx
);
765 err
|= __put_user(env
->regs
[R_ECX
], &sc
->ecx
);
766 err
|= __put_user(env
->regs
[R_EAX
], &sc
->eax
);
767 err
|= __put_user(env
->exception_index
, &sc
->trapno
);
768 err
|= __put_user(env
->error_code
, &sc
->err
);
769 err
|= __put_user(env
->eip
, &sc
->eip
);
770 err
|= __put_user(env
->segs
[R_CS
].selector
, (unsigned int *)&sc
->cs
);
771 err
|= __put_user(env
->eflags
, &sc
->eflags
);
772 err
|= __put_user(env
->regs
[R_ESP
], &sc
->esp_at_signal
);
773 err
|= __put_user(env
->segs
[R_SS
].selector
, (unsigned int *)&sc
->ss
);
775 cpu_x86_fsave(env
, fpstate_addr
, 1);
776 fpstate
->status
= fpstate
->sw
;
778 err
|= __put_user(magic
, &fpstate
->magic
);
779 err
|= __put_user(fpstate_addr
, &sc
->fpstate
);
781 /* non-iBCS2 extensions.. */
782 err
|= __put_user(mask
, &sc
->oldmask
);
783 err
|= __put_user(env
->cr
[2], &sc
->cr2
);
788 * Determine which stack to use..
791 static inline abi_ulong
792 get_sigframe(struct target_sigaction
*ka
, CPUX86State
*env
, size_t frame_size
)
796 /* Default to using normal stack */
797 esp
= env
->regs
[R_ESP
];
798 /* This is the X/Open sanctioned signal stack switching. */
799 if (ka
->sa_flags
& TARGET_SA_ONSTACK
) {
800 if (sas_ss_flags(esp
) == 0)
801 esp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
804 /* This is the legacy signal stack switching. */
806 if ((env
->segs
[R_SS
].selector
& 0xffff) != __USER_DS
&&
807 !(ka
->sa_flags
& TARGET_SA_RESTORER
) &&
809 esp
= (unsigned long) ka
->sa_restorer
;
811 return (esp
- frame_size
) & -8ul;
814 /* compare linux/arch/i386/kernel/signal.c:setup_frame() */
815 static void setup_frame(int sig
, struct target_sigaction
*ka
,
816 target_sigset_t
*set
, CPUX86State
*env
)
818 abi_ulong frame_addr
;
819 struct sigframe
*frame
;
822 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
824 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
827 err
|= __put_user(current_exec_domain_sig(sig
),
832 setup_sigcontext(&frame
->sc
, &frame
->fpstate
, env
, set
->sig
[0],
833 frame_addr
+ offsetof(struct sigframe
, fpstate
));
837 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
838 if (__put_user(set
->sig
[i
], &frame
->extramask
[i
- 1]))
842 /* Set up to return from userspace. If provided, use a stub
843 already in userspace. */
844 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
845 err
|= __put_user(ka
->sa_restorer
, &frame
->pretcode
);
848 abi_ulong retcode_addr
;
849 retcode_addr
= frame_addr
+ offsetof(struct sigframe
, retcode
);
850 err
|= __put_user(retcode_addr
, &frame
->pretcode
);
851 /* This is popl %eax ; movl $,%eax ; int $0x80 */
853 err
|= __put_user(val16
, (uint16_t *)(frame
->retcode
+0));
854 err
|= __put_user(TARGET_NR_sigreturn
, (int *)(frame
->retcode
+2));
856 err
|= __put_user(val16
, (uint16_t *)(frame
->retcode
+6));
862 /* Set up registers for signal handler */
863 env
->regs
[R_ESP
] = frame_addr
;
864 env
->eip
= ka
->_sa_handler
;
866 cpu_x86_load_seg(env
, R_DS
, __USER_DS
);
867 cpu_x86_load_seg(env
, R_ES
, __USER_DS
);
868 cpu_x86_load_seg(env
, R_SS
, __USER_DS
);
869 cpu_x86_load_seg(env
, R_CS
, __USER_CS
);
870 env
->eflags
&= ~TF_MASK
;
872 unlock_user_struct(frame
, frame_addr
, 1);
877 unlock_user_struct(frame
, frame_addr
, 1);
878 if (sig
== TARGET_SIGSEGV
)
879 ka
->_sa_handler
= TARGET_SIG_DFL
;
880 force_sig(TARGET_SIGSEGV
/* , current */);
883 /* compare linux/arch/i386/kernel/signal.c:setup_rt_frame() */
884 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
885 target_siginfo_t
*info
,
886 target_sigset_t
*set
, CPUX86State
*env
)
888 abi_ulong frame_addr
, addr
;
889 struct rt_sigframe
*frame
;
892 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
894 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
897 err
|= __put_user(current_exec_domain_sig(sig
),
899 addr
= frame_addr
+ offsetof(struct rt_sigframe
, info
);
900 err
|= __put_user(addr
, &frame
->pinfo
);
901 addr
= frame_addr
+ offsetof(struct rt_sigframe
, uc
);
902 err
|= __put_user(addr
, &frame
->puc
);
903 err
|= copy_siginfo_to_user(&frame
->info
, info
);
907 /* Create the ucontext. */
908 err
|= __put_user(0, &frame
->uc
.tuc_flags
);
909 err
|= __put_user(0, &frame
->uc
.tuc_link
);
910 err
|= __put_user(target_sigaltstack_used
.ss_sp
,
911 &frame
->uc
.tuc_stack
.ss_sp
);
912 err
|= __put_user(sas_ss_flags(get_sp_from_cpustate(env
)),
913 &frame
->uc
.tuc_stack
.ss_flags
);
914 err
|= __put_user(target_sigaltstack_used
.ss_size
,
915 &frame
->uc
.tuc_stack
.ss_size
);
916 err
|= setup_sigcontext(&frame
->uc
.tuc_mcontext
, &frame
->fpstate
,
918 frame_addr
+ offsetof(struct rt_sigframe
, fpstate
));
919 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
920 if (__put_user(set
->sig
[i
], &frame
->uc
.tuc_sigmask
.sig
[i
]))
924 /* Set up to return from userspace. If provided, use a stub
925 already in userspace. */
926 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
927 err
|= __put_user(ka
->sa_restorer
, &frame
->pretcode
);
930 addr
= frame_addr
+ offsetof(struct rt_sigframe
, retcode
);
931 err
|= __put_user(addr
, &frame
->pretcode
);
932 /* This is movl $,%eax ; int $0x80 */
933 err
|= __put_user(0xb8, (char *)(frame
->retcode
+0));
934 err
|= __put_user(TARGET_NR_rt_sigreturn
, (int *)(frame
->retcode
+1));
936 err
|= __put_user(val16
, (uint16_t *)(frame
->retcode
+5));
942 /* Set up registers for signal handler */
943 env
->regs
[R_ESP
] = frame_addr
;
944 env
->eip
= ka
->_sa_handler
;
946 cpu_x86_load_seg(env
, R_DS
, __USER_DS
);
947 cpu_x86_load_seg(env
, R_ES
, __USER_DS
);
948 cpu_x86_load_seg(env
, R_SS
, __USER_DS
);
949 cpu_x86_load_seg(env
, R_CS
, __USER_CS
);
950 env
->eflags
&= ~TF_MASK
;
952 unlock_user_struct(frame
, frame_addr
, 1);
957 unlock_user_struct(frame
, frame_addr
, 1);
958 if (sig
== TARGET_SIGSEGV
)
959 ka
->_sa_handler
= TARGET_SIG_DFL
;
960 force_sig(TARGET_SIGSEGV
/* , current */);
964 restore_sigcontext(CPUX86State
*env
, struct target_sigcontext
*sc
, int *peax
)
966 unsigned int err
= 0;
967 abi_ulong fpstate_addr
;
968 unsigned int tmpflags
;
970 cpu_x86_load_seg(env
, R_GS
, tswap16(sc
->gs
));
971 cpu_x86_load_seg(env
, R_FS
, tswap16(sc
->fs
));
972 cpu_x86_load_seg(env
, R_ES
, tswap16(sc
->es
));
973 cpu_x86_load_seg(env
, R_DS
, tswap16(sc
->ds
));
975 env
->regs
[R_EDI
] = tswapl(sc
->edi
);
976 env
->regs
[R_ESI
] = tswapl(sc
->esi
);
977 env
->regs
[R_EBP
] = tswapl(sc
->ebp
);
978 env
->regs
[R_ESP
] = tswapl(sc
->esp
);
979 env
->regs
[R_EBX
] = tswapl(sc
->ebx
);
980 env
->regs
[R_EDX
] = tswapl(sc
->edx
);
981 env
->regs
[R_ECX
] = tswapl(sc
->ecx
);
982 env
->eip
= tswapl(sc
->eip
);
984 cpu_x86_load_seg(env
, R_CS
, lduw_p(&sc
->cs
) | 3);
985 cpu_x86_load_seg(env
, R_SS
, lduw_p(&sc
->ss
) | 3);
987 tmpflags
= tswapl(sc
->eflags
);
988 env
->eflags
= (env
->eflags
& ~0x40DD5) | (tmpflags
& 0x40DD5);
989 // regs->orig_eax = -1; /* disable syscall checks */
991 fpstate_addr
= tswapl(sc
->fpstate
);
992 if (fpstate_addr
!= 0) {
993 if (!access_ok(VERIFY_READ
, fpstate_addr
,
994 sizeof(struct target_fpstate
)))
996 cpu_x86_frstor(env
, fpstate_addr
, 1);
999 *peax
= tswapl(sc
->eax
);
1005 long do_sigreturn(CPUX86State
*env
)
1007 struct sigframe
*frame
;
1008 abi_ulong frame_addr
= env
->regs
[R_ESP
] - 8;
1009 target_sigset_t target_set
;
1013 #if defined(DEBUG_SIGNAL)
1014 fprintf(stderr
, "do_sigreturn\n");
1016 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
1018 /* set blocked signals */
1019 if (__get_user(target_set
.sig
[0], &frame
->sc
.oldmask
))
1021 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
1022 if (__get_user(target_set
.sig
[i
], &frame
->extramask
[i
- 1]))
1026 target_to_host_sigset_internal(&set
, &target_set
);
1027 sigprocmask(SIG_SETMASK
, &set
, NULL
);
1029 /* restore registers */
1030 if (restore_sigcontext(env
, &frame
->sc
, &eax
))
1032 unlock_user_struct(frame
, frame_addr
, 0);
1036 unlock_user_struct(frame
, frame_addr
, 0);
1037 force_sig(TARGET_SIGSEGV
);
1041 long do_rt_sigreturn(CPUX86State
*env
)
1043 abi_ulong frame_addr
;
1044 struct rt_sigframe
*frame
;
1048 frame_addr
= env
->regs
[R_ESP
] - 4;
1049 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
1051 target_to_host_sigset(&set
, &frame
->uc
.tuc_sigmask
);
1052 sigprocmask(SIG_SETMASK
, &set
, NULL
);
1054 if (restore_sigcontext(env
, &frame
->uc
.tuc_mcontext
, &eax
))
1057 if (do_sigaltstack(frame_addr
+ offsetof(struct rt_sigframe
, uc
.tuc_stack
), 0,
1058 get_sp_from_cpustate(env
)) == -EFAULT
)
1061 unlock_user_struct(frame
, frame_addr
, 0);
1065 unlock_user_struct(frame
, frame_addr
, 0);
1066 force_sig(TARGET_SIGSEGV
);
1070 #elif defined(TARGET_ARM)
1072 struct target_sigcontext
{
1074 abi_ulong error_code
;
1093 abi_ulong fault_address
;
1096 struct target_ucontext_v1
{
1097 abi_ulong tuc_flags
;
1099 target_stack_t tuc_stack
;
1100 struct target_sigcontext tuc_mcontext
;
1101 target_sigset_t tuc_sigmask
; /* mask last for extensibility */
1104 struct target_ucontext_v2
{
1105 abi_ulong tuc_flags
;
1107 target_stack_t tuc_stack
;
1108 struct target_sigcontext tuc_mcontext
;
1109 target_sigset_t tuc_sigmask
; /* mask last for extensibility */
1110 char __unused
[128 - sizeof(target_sigset_t
)];
1111 abi_ulong tuc_regspace
[128] __attribute__((__aligned__(8)));
1114 struct target_user_vfp
{
1115 uint64_t fpregs
[32];
1119 struct target_user_vfp_exc
{
1125 struct target_vfp_sigframe
{
1128 struct target_user_vfp ufp
;
1129 struct target_user_vfp_exc ufp_exc
;
1130 } __attribute__((__aligned__(8)));
1132 struct target_iwmmxt_sigframe
{
1136 /* Note that not all the coprocessor control registers are stored here */
1143 } __attribute__((__aligned__(8)));
1145 #define TARGET_VFP_MAGIC 0x56465001
1146 #define TARGET_IWMMXT_MAGIC 0x12ef842a
1150 struct target_sigcontext sc
;
1151 abi_ulong extramask
[TARGET_NSIG_WORDS
-1];
1157 struct target_ucontext_v2 uc
;
1161 struct rt_sigframe_v1
1165 struct target_siginfo info
;
1166 struct target_ucontext_v1 uc
;
1170 struct rt_sigframe_v2
1172 struct target_siginfo info
;
1173 struct target_ucontext_v2 uc
;
1177 #define TARGET_CONFIG_CPU_32 1
1180 * For ARM syscalls, we encode the syscall number into the instruction.
1182 #define SWI_SYS_SIGRETURN (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
1183 #define SWI_SYS_RT_SIGRETURN (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
1186 * For Thumb syscalls, we pass the syscall number via r7. We therefore
1187 * need two 16-bit instructions.
1189 #define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
1190 #define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
1192 static const abi_ulong retcodes
[4] = {
1193 SWI_SYS_SIGRETURN
, SWI_THUMB_SIGRETURN
,
1194 SWI_SYS_RT_SIGRETURN
, SWI_THUMB_RT_SIGRETURN
1198 #define __get_user_error(x,p,e) __get_user(x, p)
1200 static inline int valid_user_regs(CPUState
*regs
)
1206 setup_sigcontext(struct target_sigcontext
*sc
, /*struct _fpstate *fpstate,*/
1207 CPUState
*env
, abi_ulong mask
)
1209 __put_user(env
->regs
[0], &sc
->arm_r0
);
1210 __put_user(env
->regs
[1], &sc
->arm_r1
);
1211 __put_user(env
->regs
[2], &sc
->arm_r2
);
1212 __put_user(env
->regs
[3], &sc
->arm_r3
);
1213 __put_user(env
->regs
[4], &sc
->arm_r4
);
1214 __put_user(env
->regs
[5], &sc
->arm_r5
);
1215 __put_user(env
->regs
[6], &sc
->arm_r6
);
1216 __put_user(env
->regs
[7], &sc
->arm_r7
);
1217 __put_user(env
->regs
[8], &sc
->arm_r8
);
1218 __put_user(env
->regs
[9], &sc
->arm_r9
);
1219 __put_user(env
->regs
[10], &sc
->arm_r10
);
1220 __put_user(env
->regs
[11], &sc
->arm_fp
);
1221 __put_user(env
->regs
[12], &sc
->arm_ip
);
1222 __put_user(env
->regs
[13], &sc
->arm_sp
);
1223 __put_user(env
->regs
[14], &sc
->arm_lr
);
1224 __put_user(env
->regs
[15], &sc
->arm_pc
);
1225 #ifdef TARGET_CONFIG_CPU_32
1226 __put_user(cpsr_read(env
), &sc
->arm_cpsr
);
1229 __put_user(/* current->thread.trap_no */ 0, &sc
->trap_no
);
1230 __put_user(/* current->thread.error_code */ 0, &sc
->error_code
);
1231 __put_user(/* current->thread.address */ 0, &sc
->fault_address
);
1232 __put_user(mask
, &sc
->oldmask
);
1235 static inline abi_ulong
1236 get_sigframe(struct target_sigaction
*ka
, CPUState
*regs
, int framesize
)
1238 unsigned long sp
= regs
->regs
[13];
1241 * This is the X/Open sanctioned signal stack switching.
1243 if ((ka
->sa_flags
& TARGET_SA_ONSTACK
) && !sas_ss_flags(sp
))
1244 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
1246 * ATPCS B01 mandates 8-byte alignment
1248 return (sp
- framesize
) & ~7;
1252 setup_return(CPUState
*env
, struct target_sigaction
*ka
,
1253 abi_ulong
*rc
, abi_ulong frame_addr
, int usig
, abi_ulong rc_addr
)
1255 abi_ulong handler
= ka
->_sa_handler
;
1257 int thumb
= handler
& 1;
1258 uint32_t cpsr
= cpsr_read(env
);
1267 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
1268 retcode
= ka
->sa_restorer
;
1270 unsigned int idx
= thumb
;
1272 if (ka
->sa_flags
& TARGET_SA_SIGINFO
)
1275 if (__put_user(retcodes
[idx
], rc
))
1278 retcode
= rc_addr
+ thumb
;
1281 env
->regs
[0] = usig
;
1282 env
->regs
[13] = frame_addr
;
1283 env
->regs
[14] = retcode
;
1284 env
->regs
[15] = handler
& (thumb
? ~1 : ~3);
1285 cpsr_write(env
, cpsr
, 0xffffffff);
1290 static abi_ulong
*setup_sigframe_v2_vfp(abi_ulong
*regspace
, CPUState
*env
)
1293 struct target_vfp_sigframe
*vfpframe
;
1294 vfpframe
= (struct target_vfp_sigframe
*)regspace
;
1295 __put_user(TARGET_VFP_MAGIC
, &vfpframe
->magic
);
1296 __put_user(sizeof(*vfpframe
), &vfpframe
->size
);
1297 for (i
= 0; i
< 32; i
++) {
1298 __put_user(float64_val(env
->vfp
.regs
[i
]), &vfpframe
->ufp
.fpregs
[i
]);
1300 __put_user(vfp_get_fpscr(env
), &vfpframe
->ufp
.fpscr
);
1301 __put_user(env
->vfp
.xregs
[ARM_VFP_FPEXC
], &vfpframe
->ufp_exc
.fpexc
);
1302 __put_user(env
->vfp
.xregs
[ARM_VFP_FPINST
], &vfpframe
->ufp_exc
.fpinst
);
1303 __put_user(env
->vfp
.xregs
[ARM_VFP_FPINST2
], &vfpframe
->ufp_exc
.fpinst2
);
1304 return (abi_ulong
*)(vfpframe
+1);
1307 static abi_ulong
*setup_sigframe_v2_iwmmxt(abi_ulong
*regspace
, CPUState
*env
)
1310 struct target_iwmmxt_sigframe
*iwmmxtframe
;
1311 iwmmxtframe
= (struct target_iwmmxt_sigframe
*)regspace
;
1312 __put_user(TARGET_IWMMXT_MAGIC
, &iwmmxtframe
->magic
);
1313 __put_user(sizeof(*iwmmxtframe
), &iwmmxtframe
->size
);
1314 for (i
= 0; i
< 16; i
++) {
1315 __put_user(env
->iwmmxt
.regs
[i
], &iwmmxtframe
->regs
[i
]);
1317 __put_user(env
->vfp
.xregs
[ARM_IWMMXT_wCSSF
], &iwmmxtframe
->wcssf
);
1318 __put_user(env
->vfp
.xregs
[ARM_IWMMXT_wCASF
], &iwmmxtframe
->wcssf
);
1319 __put_user(env
->vfp
.xregs
[ARM_IWMMXT_wCGR0
], &iwmmxtframe
->wcgr0
);
1320 __put_user(env
->vfp
.xregs
[ARM_IWMMXT_wCGR1
], &iwmmxtframe
->wcgr1
);
1321 __put_user(env
->vfp
.xregs
[ARM_IWMMXT_wCGR2
], &iwmmxtframe
->wcgr2
);
1322 __put_user(env
->vfp
.xregs
[ARM_IWMMXT_wCGR3
], &iwmmxtframe
->wcgr3
);
1323 return (abi_ulong
*)(iwmmxtframe
+1);
1326 static void setup_sigframe_v2(struct target_ucontext_v2
*uc
,
1327 target_sigset_t
*set
, CPUState
*env
)
1329 struct target_sigaltstack stack
;
1331 abi_ulong
*regspace
;
1333 /* Clear all the bits of the ucontext we don't use. */
1334 memset(uc
, 0, offsetof(struct target_ucontext_v2
, tuc_mcontext
));
1336 memset(&stack
, 0, sizeof(stack
));
1337 __put_user(target_sigaltstack_used
.ss_sp
, &stack
.ss_sp
);
1338 __put_user(target_sigaltstack_used
.ss_size
, &stack
.ss_size
);
1339 __put_user(sas_ss_flags(get_sp_from_cpustate(env
)), &stack
.ss_flags
);
1340 memcpy(&uc
->tuc_stack
, &stack
, sizeof(stack
));
1342 setup_sigcontext(&uc
->tuc_mcontext
, env
, set
->sig
[0]);
1343 /* Save coprocessor signal frame. */
1344 regspace
= uc
->tuc_regspace
;
1345 if (arm_feature(env
, ARM_FEATURE_VFP
)) {
1346 regspace
= setup_sigframe_v2_vfp(regspace
, env
);
1348 if (arm_feature(env
, ARM_FEATURE_IWMMXT
)) {
1349 regspace
= setup_sigframe_v2_iwmmxt(regspace
, env
);
1352 /* Write terminating magic word */
1353 __put_user(0, regspace
);
1355 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
1356 __put_user(set
->sig
[i
], &uc
->tuc_sigmask
.sig
[i
]);
1360 /* compare linux/arch/arm/kernel/signal.c:setup_frame() */
1361 static void setup_frame_v1(int usig
, struct target_sigaction
*ka
,
1362 target_sigset_t
*set
, CPUState
*regs
)
1364 struct sigframe_v1
*frame
;
1365 abi_ulong frame_addr
= get_sigframe(ka
, regs
, sizeof(*frame
));
1368 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
1371 setup_sigcontext(&frame
->sc
, regs
, set
->sig
[0]);
1373 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
1374 if (__put_user(set
->sig
[i
], &frame
->extramask
[i
- 1]))
1378 setup_return(regs
, ka
, &frame
->retcode
, frame_addr
, usig
,
1379 frame_addr
+ offsetof(struct sigframe_v1
, retcode
));
1382 unlock_user_struct(frame
, frame_addr
, 1);
1385 static void setup_frame_v2(int usig
, struct target_sigaction
*ka
,
1386 target_sigset_t
*set
, CPUState
*regs
)
1388 struct sigframe_v2
*frame
;
1389 abi_ulong frame_addr
= get_sigframe(ka
, regs
, sizeof(*frame
));
1391 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
1394 setup_sigframe_v2(&frame
->uc
, set
, regs
);
1396 setup_return(regs
, ka
, &frame
->retcode
, frame_addr
, usig
,
1397 frame_addr
+ offsetof(struct sigframe_v2
, retcode
));
1399 unlock_user_struct(frame
, frame_addr
, 1);
1402 static void setup_frame(int usig
, struct target_sigaction
*ka
,
1403 target_sigset_t
*set
, CPUState
*regs
)
1405 if (get_osversion() >= 0x020612) {
1406 setup_frame_v2(usig
, ka
, set
, regs
);
1408 setup_frame_v1(usig
, ka
, set
, regs
);
1412 /* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */
1413 static void setup_rt_frame_v1(int usig
, struct target_sigaction
*ka
,
1414 target_siginfo_t
*info
,
1415 target_sigset_t
*set
, CPUState
*env
)
1417 struct rt_sigframe_v1
*frame
;
1418 abi_ulong frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
1419 struct target_sigaltstack stack
;
1421 abi_ulong info_addr
, uc_addr
;
1423 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
1426 info_addr
= frame_addr
+ offsetof(struct rt_sigframe_v1
, info
);
1427 __put_user(info_addr
, &frame
->pinfo
);
1428 uc_addr
= frame_addr
+ offsetof(struct rt_sigframe_v1
, uc
);
1429 __put_user(uc_addr
, &frame
->puc
);
1430 copy_siginfo_to_user(&frame
->info
, info
);
1432 /* Clear all the bits of the ucontext we don't use. */
1433 memset(&frame
->uc
, 0, offsetof(struct target_ucontext_v1
, tuc_mcontext
));
1435 memset(&stack
, 0, sizeof(stack
));
1436 __put_user(target_sigaltstack_used
.ss_sp
, &stack
.ss_sp
);
1437 __put_user(target_sigaltstack_used
.ss_size
, &stack
.ss_size
);
1438 __put_user(sas_ss_flags(get_sp_from_cpustate(env
)), &stack
.ss_flags
);
1439 memcpy(&frame
->uc
.tuc_stack
, &stack
, sizeof(stack
));
1441 setup_sigcontext(&frame
->uc
.tuc_mcontext
, env
, set
->sig
[0]);
1442 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
1443 if (__put_user(set
->sig
[i
], &frame
->uc
.tuc_sigmask
.sig
[i
]))
1447 setup_return(env
, ka
, &frame
->retcode
, frame_addr
, usig
,
1448 frame_addr
+ offsetof(struct rt_sigframe_v1
, retcode
));
1450 env
->regs
[1] = info_addr
;
1451 env
->regs
[2] = uc_addr
;
1454 unlock_user_struct(frame
, frame_addr
, 1);
1457 static void setup_rt_frame_v2(int usig
, struct target_sigaction
*ka
,
1458 target_siginfo_t
*info
,
1459 target_sigset_t
*set
, CPUState
*env
)
1461 struct rt_sigframe_v2
*frame
;
1462 abi_ulong frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
1463 abi_ulong info_addr
, uc_addr
;
1465 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
1468 info_addr
= frame_addr
+ offsetof(struct rt_sigframe_v2
, info
);
1469 uc_addr
= frame_addr
+ offsetof(struct rt_sigframe_v2
, uc
);
1470 copy_siginfo_to_user(&frame
->info
, info
);
1472 setup_sigframe_v2(&frame
->uc
, set
, env
);
1474 setup_return(env
, ka
, &frame
->retcode
, frame_addr
, usig
,
1475 frame_addr
+ offsetof(struct rt_sigframe_v2
, retcode
));
1477 env
->regs
[1] = info_addr
;
1478 env
->regs
[2] = uc_addr
;
1480 unlock_user_struct(frame
, frame_addr
, 1);
1483 static void setup_rt_frame(int usig
, struct target_sigaction
*ka
,
1484 target_siginfo_t
*info
,
1485 target_sigset_t
*set
, CPUState
*env
)
1487 if (get_osversion() >= 0x020612) {
1488 setup_rt_frame_v2(usig
, ka
, info
, set
, env
);
1490 setup_rt_frame_v1(usig
, ka
, info
, set
, env
);
1495 restore_sigcontext(CPUState
*env
, struct target_sigcontext
*sc
)
1500 __get_user_error(env
->regs
[0], &sc
->arm_r0
, err
);
1501 __get_user_error(env
->regs
[1], &sc
->arm_r1
, err
);
1502 __get_user_error(env
->regs
[2], &sc
->arm_r2
, err
);
1503 __get_user_error(env
->regs
[3], &sc
->arm_r3
, err
);
1504 __get_user_error(env
->regs
[4], &sc
->arm_r4
, err
);
1505 __get_user_error(env
->regs
[5], &sc
->arm_r5
, err
);
1506 __get_user_error(env
->regs
[6], &sc
->arm_r6
, err
);
1507 __get_user_error(env
->regs
[7], &sc
->arm_r7
, err
);
1508 __get_user_error(env
->regs
[8], &sc
->arm_r8
, err
);
1509 __get_user_error(env
->regs
[9], &sc
->arm_r9
, err
);
1510 __get_user_error(env
->regs
[10], &sc
->arm_r10
, err
);
1511 __get_user_error(env
->regs
[11], &sc
->arm_fp
, err
);
1512 __get_user_error(env
->regs
[12], &sc
->arm_ip
, err
);
1513 __get_user_error(env
->regs
[13], &sc
->arm_sp
, err
);
1514 __get_user_error(env
->regs
[14], &sc
->arm_lr
, err
);
1515 __get_user_error(env
->regs
[15], &sc
->arm_pc
, err
);
1516 #ifdef TARGET_CONFIG_CPU_32
1517 __get_user_error(cpsr
, &sc
->arm_cpsr
, err
);
1518 cpsr_write(env
, cpsr
, CPSR_USER
| CPSR_EXEC
);
1521 err
|= !valid_user_regs(env
);
1526 static long do_sigreturn_v1(CPUState
*env
)
1528 abi_ulong frame_addr
;
1529 struct sigframe_v1
*frame
;
1530 target_sigset_t set
;
1535 * Since we stacked the signal on a 64-bit boundary,
1536 * then 'sp' should be word aligned here. If it's
1537 * not, then the user is trying to mess with us.
1539 if (env
->regs
[13] & 7)
1542 frame_addr
= env
->regs
[13];
1543 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
1546 if (__get_user(set
.sig
[0], &frame
->sc
.oldmask
))
1548 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
1549 if (__get_user(set
.sig
[i
], &frame
->extramask
[i
- 1]))
1553 target_to_host_sigset_internal(&host_set
, &set
);
1554 sigprocmask(SIG_SETMASK
, &host_set
, NULL
);
1556 if (restore_sigcontext(env
, &frame
->sc
))
1560 /* Send SIGTRAP if we're single-stepping */
1561 if (ptrace_cancel_bpt(current
))
1562 send_sig(SIGTRAP
, current
, 1);
1564 unlock_user_struct(frame
, frame_addr
, 0);
1565 return env
->regs
[0];
1568 unlock_user_struct(frame
, frame_addr
, 0);
1569 force_sig(TARGET_SIGSEGV
/* , current */);
1573 static abi_ulong
*restore_sigframe_v2_vfp(CPUState
*env
, abi_ulong
*regspace
)
1576 abi_ulong magic
, sz
;
1577 uint32_t fpscr
, fpexc
;
1578 struct target_vfp_sigframe
*vfpframe
;
1579 vfpframe
= (struct target_vfp_sigframe
*)regspace
;
1581 __get_user(magic
, &vfpframe
->magic
);
1582 __get_user(sz
, &vfpframe
->size
);
1583 if (magic
!= TARGET_VFP_MAGIC
|| sz
!= sizeof(*vfpframe
)) {
1586 for (i
= 0; i
< 32; i
++) {
1587 __get_user(float64_val(env
->vfp
.regs
[i
]), &vfpframe
->ufp
.fpregs
[i
]);
1589 __get_user(fpscr
, &vfpframe
->ufp
.fpscr
);
1590 vfp_set_fpscr(env
, fpscr
);
1591 __get_user(fpexc
, &vfpframe
->ufp_exc
.fpexc
);
1592 /* Sanitise FPEXC: ensure VFP is enabled, FPINST2 is invalid
1593 * and the exception flag is cleared
1596 fpexc
&= ~((1 << 31) | (1 << 28));
1597 env
->vfp
.xregs
[ARM_VFP_FPEXC
] = fpexc
;
1598 __get_user(env
->vfp
.xregs
[ARM_VFP_FPINST
], &vfpframe
->ufp_exc
.fpinst
);
1599 __get_user(env
->vfp
.xregs
[ARM_VFP_FPINST2
], &vfpframe
->ufp_exc
.fpinst2
);
1600 return (abi_ulong
*)(vfpframe
+ 1);
1603 static abi_ulong
*restore_sigframe_v2_iwmmxt(CPUState
*env
, abi_ulong
*regspace
)
1606 abi_ulong magic
, sz
;
1607 struct target_iwmmxt_sigframe
*iwmmxtframe
;
1608 iwmmxtframe
= (struct target_iwmmxt_sigframe
*)regspace
;
1610 __get_user(magic
, &iwmmxtframe
->magic
);
1611 __get_user(sz
, &iwmmxtframe
->size
);
1612 if (magic
!= TARGET_IWMMXT_MAGIC
|| sz
!= sizeof(*iwmmxtframe
)) {
1615 for (i
= 0; i
< 16; i
++) {
1616 __get_user(env
->iwmmxt
.regs
[i
], &iwmmxtframe
->regs
[i
]);
1618 __get_user(env
->vfp
.xregs
[ARM_IWMMXT_wCSSF
], &iwmmxtframe
->wcssf
);
1619 __get_user(env
->vfp
.xregs
[ARM_IWMMXT_wCASF
], &iwmmxtframe
->wcssf
);
1620 __get_user(env
->vfp
.xregs
[ARM_IWMMXT_wCGR0
], &iwmmxtframe
->wcgr0
);
1621 __get_user(env
->vfp
.xregs
[ARM_IWMMXT_wCGR1
], &iwmmxtframe
->wcgr1
);
1622 __get_user(env
->vfp
.xregs
[ARM_IWMMXT_wCGR2
], &iwmmxtframe
->wcgr2
);
1623 __get_user(env
->vfp
.xregs
[ARM_IWMMXT_wCGR3
], &iwmmxtframe
->wcgr3
);
1624 return (abi_ulong
*)(iwmmxtframe
+ 1);
1627 static int do_sigframe_return_v2(CPUState
*env
, target_ulong frame_addr
,
1628 struct target_ucontext_v2
*uc
)
1631 abi_ulong
*regspace
;
1633 target_to_host_sigset(&host_set
, &uc
->tuc_sigmask
);
1634 sigprocmask(SIG_SETMASK
, &host_set
, NULL
);
1636 if (restore_sigcontext(env
, &uc
->tuc_mcontext
))
1639 /* Restore coprocessor signal frame */
1640 regspace
= uc
->tuc_regspace
;
1641 if (arm_feature(env
, ARM_FEATURE_VFP
)) {
1642 regspace
= restore_sigframe_v2_vfp(env
, regspace
);
1647 if (arm_feature(env
, ARM_FEATURE_IWMMXT
)) {
1648 regspace
= restore_sigframe_v2_iwmmxt(env
, regspace
);
1654 if (do_sigaltstack(frame_addr
+ offsetof(struct target_ucontext_v2
, tuc_stack
), 0, get_sp_from_cpustate(env
)) == -EFAULT
)
1658 /* Send SIGTRAP if we're single-stepping */
1659 if (ptrace_cancel_bpt(current
))
1660 send_sig(SIGTRAP
, current
, 1);
1666 static long do_sigreturn_v2(CPUState
*env
)
1668 abi_ulong frame_addr
;
1669 struct sigframe_v2
*frame
;
1672 * Since we stacked the signal on a 64-bit boundary,
1673 * then 'sp' should be word aligned here. If it's
1674 * not, then the user is trying to mess with us.
1676 if (env
->regs
[13] & 7)
1679 frame_addr
= env
->regs
[13];
1680 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
1683 if (do_sigframe_return_v2(env
, frame_addr
, &frame
->uc
))
1686 unlock_user_struct(frame
, frame_addr
, 0);
1687 return env
->regs
[0];
1690 unlock_user_struct(frame
, frame_addr
, 0);
1691 force_sig(TARGET_SIGSEGV
/* , current */);
1695 long do_sigreturn(CPUState
*env
)
1697 if (get_osversion() >= 0x020612) {
1698 return do_sigreturn_v2(env
);
1700 return do_sigreturn_v1(env
);
1704 static long do_rt_sigreturn_v1(CPUState
*env
)
1706 abi_ulong frame_addr
;
1707 struct rt_sigframe_v1
*frame
;
1711 * Since we stacked the signal on a 64-bit boundary,
1712 * then 'sp' should be word aligned here. If it's
1713 * not, then the user is trying to mess with us.
1715 if (env
->regs
[13] & 7)
1718 frame_addr
= env
->regs
[13];
1719 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
1722 target_to_host_sigset(&host_set
, &frame
->uc
.tuc_sigmask
);
1723 sigprocmask(SIG_SETMASK
, &host_set
, NULL
);
1725 if (restore_sigcontext(env
, &frame
->uc
.tuc_mcontext
))
1728 if (do_sigaltstack(frame_addr
+ offsetof(struct rt_sigframe_v1
, uc
.tuc_stack
), 0, get_sp_from_cpustate(env
)) == -EFAULT
)
1732 /* Send SIGTRAP if we're single-stepping */
1733 if (ptrace_cancel_bpt(current
))
1734 send_sig(SIGTRAP
, current
, 1);
1736 unlock_user_struct(frame
, frame_addr
, 0);
1737 return env
->regs
[0];
1740 unlock_user_struct(frame
, frame_addr
, 0);
1741 force_sig(TARGET_SIGSEGV
/* , current */);
1745 static long do_rt_sigreturn_v2(CPUState
*env
)
1747 abi_ulong frame_addr
;
1748 struct rt_sigframe_v2
*frame
;
1751 * Since we stacked the signal on a 64-bit boundary,
1752 * then 'sp' should be word aligned here. If it's
1753 * not, then the user is trying to mess with us.
1755 if (env
->regs
[13] & 7)
1758 frame_addr
= env
->regs
[13];
1759 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
1762 if (do_sigframe_return_v2(env
, frame_addr
, &frame
->uc
))
1765 unlock_user_struct(frame
, frame_addr
, 0);
1766 return env
->regs
[0];
1769 unlock_user_struct(frame
, frame_addr
, 0);
1770 force_sig(TARGET_SIGSEGV
/* , current */);
1774 long do_rt_sigreturn(CPUState
*env
)
1776 if (get_osversion() >= 0x020612) {
1777 return do_rt_sigreturn_v2(env
);
1779 return do_rt_sigreturn_v1(env
);
1783 #elif defined(TARGET_SPARC)
1785 #define __SUNOS_MAXWIN 31
1787 /* This is what SunOS does, so shall I. */
1788 struct target_sigcontext
{
1789 abi_ulong sigc_onstack
; /* state to restore */
1791 abi_ulong sigc_mask
; /* sigmask to restore */
1792 abi_ulong sigc_sp
; /* stack pointer */
1793 abi_ulong sigc_pc
; /* program counter */
1794 abi_ulong sigc_npc
; /* next program counter */
1795 abi_ulong sigc_psr
; /* for condition codes etc */
1796 abi_ulong sigc_g1
; /* User uses these two registers */
1797 abi_ulong sigc_o0
; /* within the trampoline code. */
1799 /* Now comes information regarding the users window set
1800 * at the time of the signal.
1802 abi_ulong sigc_oswins
; /* outstanding windows */
1804 /* stack ptrs for each regwin buf */
1805 char *sigc_spbuf
[__SUNOS_MAXWIN
];
1807 /* Windows to restore after signal */
1809 abi_ulong locals
[8];
1811 } sigc_wbuf
[__SUNOS_MAXWIN
];
1813 /* A Sparc stack frame */
1814 struct sparc_stackf
{
1815 abi_ulong locals
[8];
1817 /* It's simpler to treat fp and callers_pc as elements of ins[]
1818 * since we never need to access them ourselves.
1822 abi_ulong xxargs
[1];
1831 abi_ulong u_regs
[16]; /* globals and ins */
1837 unsigned long si_float_regs
[32];
1838 unsigned long si_fsr
;
1839 unsigned long si_fpqdepth
;
1841 unsigned long *insn_addr
;
1844 } qemu_siginfo_fpu_t
;
1847 struct target_signal_frame
{
1848 struct sparc_stackf ss
;
1851 abi_ulong insns
[2] __attribute__ ((aligned (8)));
1852 abi_ulong extramask
[TARGET_NSIG_WORDS
- 1];
1853 abi_ulong extra_size
; /* Should be 0 */
1854 qemu_siginfo_fpu_t fpu_state
;
1856 struct target_rt_signal_frame
{
1857 struct sparc_stackf ss
;
1862 unsigned int insns
[2];
1864 unsigned int extra_size
; /* Should be 0 */
1865 qemu_siginfo_fpu_t fpu_state
;
1879 #define UREG_FP UREG_I6
1880 #define UREG_SP UREG_O6
1882 static inline abi_ulong
get_sigframe(struct target_sigaction
*sa
,
1883 CPUState
*env
, unsigned long framesize
)
1887 sp
= env
->regwptr
[UREG_FP
];
1889 /* This is the X/Open sanctioned signal stack switching. */
1890 if (sa
->sa_flags
& TARGET_SA_ONSTACK
) {
1891 if (!on_sig_stack(sp
)
1892 && !((target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
) & 7))
1893 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
1895 return sp
- framesize
;
1899 setup___siginfo(__siginfo_t
*si
, CPUState
*env
, abi_ulong mask
)
1903 err
|= __put_user(env
->psr
, &si
->si_regs
.psr
);
1904 err
|= __put_user(env
->pc
, &si
->si_regs
.pc
);
1905 err
|= __put_user(env
->npc
, &si
->si_regs
.npc
);
1906 err
|= __put_user(env
->y
, &si
->si_regs
.y
);
1907 for (i
=0; i
< 8; i
++) {
1908 err
|= __put_user(env
->gregs
[i
], &si
->si_regs
.u_regs
[i
]);
1910 for (i
=0; i
< 8; i
++) {
1911 err
|= __put_user(env
->regwptr
[UREG_I0
+ i
], &si
->si_regs
.u_regs
[i
+8]);
1913 err
|= __put_user(mask
, &si
->si_mask
);
1919 setup_sigcontext(struct target_sigcontext
*sc
, /*struct _fpstate *fpstate,*/
1920 CPUState
*env
, unsigned long mask
)
1924 err
|= __put_user(mask
, &sc
->sigc_mask
);
1925 err
|= __put_user(env
->regwptr
[UREG_SP
], &sc
->sigc_sp
);
1926 err
|= __put_user(env
->pc
, &sc
->sigc_pc
);
1927 err
|= __put_user(env
->npc
, &sc
->sigc_npc
);
1928 err
|= __put_user(env
->psr
, &sc
->sigc_psr
);
1929 err
|= __put_user(env
->gregs
[1], &sc
->sigc_g1
);
1930 err
|= __put_user(env
->regwptr
[UREG_O0
], &sc
->sigc_o0
);
1935 #define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7)))
1937 static void setup_frame(int sig
, struct target_sigaction
*ka
,
1938 target_sigset_t
*set
, CPUState
*env
)
1941 struct target_signal_frame
*sf
;
1942 int sigframe_size
, err
, i
;
1944 /* 1. Make sure everything is clean */
1945 //synchronize_user_stack();
1947 sigframe_size
= NF_ALIGNEDSZ
;
1948 sf_addr
= get_sigframe(ka
, env
, sigframe_size
);
1950 sf
= lock_user(VERIFY_WRITE
, sf_addr
,
1951 sizeof(struct target_signal_frame
), 0);
1955 //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1957 if (invalid_frame_pointer(sf
, sigframe_size
))
1958 goto sigill_and_return
;
1960 /* 2. Save the current process state */
1961 err
= setup___siginfo(&sf
->info
, env
, set
->sig
[0]);
1962 err
|= __put_user(0, &sf
->extra_size
);
1964 //err |= save_fpu_state(regs, &sf->fpu_state);
1965 //err |= __put_user(&sf->fpu_state, &sf->fpu_save);
1967 err
|= __put_user(set
->sig
[0], &sf
->info
.si_mask
);
1968 for (i
= 0; i
< TARGET_NSIG_WORDS
- 1; i
++) {
1969 err
|= __put_user(set
->sig
[i
+ 1], &sf
->extramask
[i
]);
1972 for (i
= 0; i
< 8; i
++) {
1973 err
|= __put_user(env
->regwptr
[i
+ UREG_L0
], &sf
->ss
.locals
[i
]);
1975 for (i
= 0; i
< 8; i
++) {
1976 err
|= __put_user(env
->regwptr
[i
+ UREG_I0
], &sf
->ss
.ins
[i
]);
1981 /* 3. signal handler back-trampoline and parameters */
1982 env
->regwptr
[UREG_FP
] = sf_addr
;
1983 env
->regwptr
[UREG_I0
] = sig
;
1984 env
->regwptr
[UREG_I1
] = sf_addr
+
1985 offsetof(struct target_signal_frame
, info
);
1986 env
->regwptr
[UREG_I2
] = sf_addr
+
1987 offsetof(struct target_signal_frame
, info
);
1989 /* 4. signal handler */
1990 env
->pc
= ka
->_sa_handler
;
1991 env
->npc
= (env
->pc
+ 4);
1992 /* 5. return to kernel instructions */
1993 if (ka
->sa_restorer
)
1994 env
->regwptr
[UREG_I7
] = ka
->sa_restorer
;
1998 env
->regwptr
[UREG_I7
] = sf_addr
+
1999 offsetof(struct target_signal_frame
, insns
) - 2 * 4;
2001 /* mov __NR_sigreturn, %g1 */
2003 err
|= __put_user(val32
, &sf
->insns
[0]);
2007 err
|= __put_user(val32
, &sf
->insns
[1]);
2011 /* Flush instruction space. */
2012 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
2015 unlock_user(sf
, sf_addr
, sizeof(struct target_signal_frame
));
2019 force_sig(TARGET_SIGILL
);
2022 //fprintf(stderr, "force_sig\n");
2023 unlock_user(sf
, sf_addr
, sizeof(struct target_signal_frame
));
2024 force_sig(TARGET_SIGSEGV
);
2027 restore_fpu_state(CPUState
*env
, qemu_siginfo_fpu_t
*fpu
)
2032 if (current
->flags
& PF_USEDFPU
)
2033 regs
->psr
&= ~PSR_EF
;
2035 if (current
== last_task_used_math
) {
2036 last_task_used_math
= 0;
2037 regs
->psr
&= ~PSR_EF
;
2040 current
->used_math
= 1;
2041 current
->flags
&= ~PF_USEDFPU
;
2044 if (verify_area (VERIFY_READ
, fpu
, sizeof(*fpu
)))
2049 /* XXX: incorrect */
2050 err
= __copy_from_user(&env
->fpr
[0], &fpu
->si_float_regs
[0],
2051 (sizeof(unsigned long) * 32));
2053 err
|= __get_user(env
->fsr
, &fpu
->si_fsr
);
2055 err
|= __get_user(current
->thread
.fpqdepth
, &fpu
->si_fpqdepth
);
2056 if (current
->thread
.fpqdepth
!= 0)
2057 err
|= __copy_from_user(¤t
->thread
.fpqueue
[0],
2058 &fpu
->si_fpqueue
[0],
2059 ((sizeof(unsigned long) +
2060 (sizeof(unsigned long *)))*16));
2066 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
2067 target_siginfo_t
*info
,
2068 target_sigset_t
*set
, CPUState
*env
)
2070 fprintf(stderr
, "setup_rt_frame: not implemented\n");
2073 long do_sigreturn(CPUState
*env
)
2076 struct target_signal_frame
*sf
;
2077 uint32_t up_psr
, pc
, npc
;
2078 target_sigset_t set
;
2082 sf_addr
= env
->regwptr
[UREG_FP
];
2083 if (!lock_user_struct(VERIFY_READ
, sf
, sf_addr
, 1))
2086 fprintf(stderr
, "sigreturn\n");
2087 fprintf(stderr
, "sf: %x pc %x fp %x sp %x\n", sf
, env
->pc
, env
->regwptr
[UREG_FP
], env
->regwptr
[UREG_SP
]);
2089 //cpu_dump_state(env, stderr, fprintf, 0);
2091 /* 1. Make sure we are not getting garbage from the user */
2096 err
= __get_user(pc
, &sf
->info
.si_regs
.pc
);
2097 err
|= __get_user(npc
, &sf
->info
.si_regs
.npc
);
2102 /* 2. Restore the state */
2103 err
|= __get_user(up_psr
, &sf
->info
.si_regs
.psr
);
2105 /* User can only change condition codes and FPU enabling in %psr. */
2106 env
->psr
= (up_psr
& (PSR_ICC
/* | PSR_EF */))
2107 | (env
->psr
& ~(PSR_ICC
/* | PSR_EF */));
2111 err
|= __get_user(env
->y
, &sf
->info
.si_regs
.y
);
2112 for (i
=0; i
< 8; i
++) {
2113 err
|= __get_user(env
->gregs
[i
], &sf
->info
.si_regs
.u_regs
[i
]);
2115 for (i
=0; i
< 8; i
++) {
2116 err
|= __get_user(env
->regwptr
[i
+ UREG_I0
], &sf
->info
.si_regs
.u_regs
[i
+8]);
2119 /* FIXME: implement FPU save/restore:
2120 * __get_user(fpu_save, &sf->fpu_save);
2122 * err |= restore_fpu_state(env, fpu_save);
2125 /* This is pretty much atomic, no amount locking would prevent
2126 * the races which exist anyways.
2128 err
|= __get_user(set
.sig
[0], &sf
->info
.si_mask
);
2129 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
2130 err
|= (__get_user(set
.sig
[i
], &sf
->extramask
[i
- 1]));
2133 target_to_host_sigset_internal(&host_set
, &set
);
2134 sigprocmask(SIG_SETMASK
, &host_set
, NULL
);
2138 unlock_user_struct(sf
, sf_addr
, 0);
2139 return env
->regwptr
[0];
2142 unlock_user_struct(sf
, sf_addr
, 0);
2143 force_sig(TARGET_SIGSEGV
);
2146 long do_rt_sigreturn(CPUState
*env
)
2148 fprintf(stderr
, "do_rt_sigreturn: not implemented\n");
2149 return -TARGET_ENOSYS
;
2152 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
2174 typedef abi_ulong target_mc_greg_t
;
2175 typedef target_mc_greg_t target_mc_gregset_t
[MC_NGREG
];
2177 struct target_mc_fq
{
2178 abi_ulong
*mcfq_addr
;
2182 struct target_mc_fpu
{
2186 //uint128_t qregs[16];
2188 abi_ulong mcfpu_fsr
;
2189 abi_ulong mcfpu_fprs
;
2190 abi_ulong mcfpu_gsr
;
2191 struct target_mc_fq
*mcfpu_fq
;
2192 unsigned char mcfpu_qcnt
;
2193 unsigned char mcfpu_qentsz
;
2194 unsigned char mcfpu_enab
;
2196 typedef struct target_mc_fpu target_mc_fpu_t
;
2199 target_mc_gregset_t mc_gregs
;
2200 target_mc_greg_t mc_fp
;
2201 target_mc_greg_t mc_i7
;
2202 target_mc_fpu_t mc_fpregs
;
2203 } target_mcontext_t
;
2205 struct target_ucontext
{
2206 struct target_ucontext
*tuc_link
;
2207 abi_ulong tuc_flags
;
2208 target_sigset_t tuc_sigmask
;
2209 target_mcontext_t tuc_mcontext
;
2212 /* A V9 register window */
2213 struct target_reg_window
{
2214 abi_ulong locals
[8];
2218 #define TARGET_STACK_BIAS 2047
2220 /* {set, get}context() needed for 64-bit SparcLinux userland. */
2221 void sparc64_set_context(CPUSPARCState
*env
)
2224 struct target_ucontext
*ucp
;
2225 target_mc_gregset_t
*grp
;
2226 abi_ulong pc
, npc
, tstate
;
2227 abi_ulong fp
, i7
, w_addr
;
2231 ucp_addr
= env
->regwptr
[UREG_I0
];
2232 if (!lock_user_struct(VERIFY_READ
, ucp
, ucp_addr
, 1))
2234 grp
= &ucp
->tuc_mcontext
.mc_gregs
;
2235 err
= __get_user(pc
, &((*grp
)[MC_PC
]));
2236 err
|= __get_user(npc
, &((*grp
)[MC_NPC
]));
2237 if (err
|| ((pc
| npc
) & 3))
2239 if (env
->regwptr
[UREG_I1
]) {
2240 target_sigset_t target_set
;
2243 if (TARGET_NSIG_WORDS
== 1) {
2244 if (__get_user(target_set
.sig
[0], &ucp
->tuc_sigmask
.sig
[0]))
2247 abi_ulong
*src
, *dst
;
2248 src
= ucp
->tuc_sigmask
.sig
;
2249 dst
= target_set
.sig
;
2250 for (i
= 0; i
< sizeof(target_sigset_t
) / sizeof(abi_ulong
);
2252 err
|= __get_user(*dst
, src
);
2256 target_to_host_sigset_internal(&set
, &target_set
);
2257 sigprocmask(SIG_SETMASK
, &set
, NULL
);
2261 err
|= __get_user(env
->y
, &((*grp
)[MC_Y
]));
2262 err
|= __get_user(tstate
, &((*grp
)[MC_TSTATE
]));
2263 env
->asi
= (tstate
>> 24) & 0xff;
2264 cpu_put_ccr(env
, tstate
>> 32);
2265 cpu_put_cwp64(env
, tstate
& 0x1f);
2266 err
|= __get_user(env
->gregs
[1], (&(*grp
)[MC_G1
]));
2267 err
|= __get_user(env
->gregs
[2], (&(*grp
)[MC_G2
]));
2268 err
|= __get_user(env
->gregs
[3], (&(*grp
)[MC_G3
]));
2269 err
|= __get_user(env
->gregs
[4], (&(*grp
)[MC_G4
]));
2270 err
|= __get_user(env
->gregs
[5], (&(*grp
)[MC_G5
]));
2271 err
|= __get_user(env
->gregs
[6], (&(*grp
)[MC_G6
]));
2272 err
|= __get_user(env
->gregs
[7], (&(*grp
)[MC_G7
]));
2273 err
|= __get_user(env
->regwptr
[UREG_I0
], (&(*grp
)[MC_O0
]));
2274 err
|= __get_user(env
->regwptr
[UREG_I1
], (&(*grp
)[MC_O1
]));
2275 err
|= __get_user(env
->regwptr
[UREG_I2
], (&(*grp
)[MC_O2
]));
2276 err
|= __get_user(env
->regwptr
[UREG_I3
], (&(*grp
)[MC_O3
]));
2277 err
|= __get_user(env
->regwptr
[UREG_I4
], (&(*grp
)[MC_O4
]));
2278 err
|= __get_user(env
->regwptr
[UREG_I5
], (&(*grp
)[MC_O5
]));
2279 err
|= __get_user(env
->regwptr
[UREG_I6
], (&(*grp
)[MC_O6
]));
2280 err
|= __get_user(env
->regwptr
[UREG_I7
], (&(*grp
)[MC_O7
]));
2282 err
|= __get_user(fp
, &(ucp
->tuc_mcontext
.mc_fp
));
2283 err
|= __get_user(i7
, &(ucp
->tuc_mcontext
.mc_i7
));
2285 w_addr
= TARGET_STACK_BIAS
+env
->regwptr
[UREG_I6
];
2286 if (put_user(fp
, w_addr
+ offsetof(struct target_reg_window
, ins
[6]),
2289 if (put_user(i7
, w_addr
+ offsetof(struct target_reg_window
, ins
[7]),
2292 /* FIXME this does not match how the kernel handles the FPU in
2293 * its sparc64_set_context implementation. In particular the FPU
2294 * is only restored if fenab is non-zero in:
2295 * __get_user(fenab, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_enab));
2297 err
|= __get_user(env
->fprs
, &(ucp
->tuc_mcontext
.mc_fpregs
.mcfpu_fprs
));
2299 uint32_t *src
, *dst
;
2300 src
= ucp
->tuc_mcontext
.mc_fpregs
.mcfpu_fregs
.sregs
;
2302 /* XXX: check that the CPU storage is the same as user context */
2303 for (i
= 0; i
< 64; i
++, dst
++, src
++)
2304 err
|= __get_user(*dst
, src
);
2306 err
|= __get_user(env
->fsr
,
2307 &(ucp
->tuc_mcontext
.mc_fpregs
.mcfpu_fsr
));
2308 err
|= __get_user(env
->gsr
,
2309 &(ucp
->tuc_mcontext
.mc_fpregs
.mcfpu_gsr
));
2312 unlock_user_struct(ucp
, ucp_addr
, 0);
2315 unlock_user_struct(ucp
, ucp_addr
, 0);
2316 force_sig(TARGET_SIGSEGV
);
2319 void sparc64_get_context(CPUSPARCState
*env
)
2322 struct target_ucontext
*ucp
;
2323 target_mc_gregset_t
*grp
;
2324 target_mcontext_t
*mcp
;
2325 abi_ulong fp
, i7
, w_addr
;
2328 target_sigset_t target_set
;
2331 ucp_addr
= env
->regwptr
[UREG_I0
];
2332 if (!lock_user_struct(VERIFY_WRITE
, ucp
, ucp_addr
, 0))
2335 mcp
= &ucp
->tuc_mcontext
;
2336 grp
= &mcp
->mc_gregs
;
2338 /* Skip over the trap instruction, first. */
2344 sigprocmask(0, NULL
, &set
);
2345 host_to_target_sigset_internal(&target_set
, &set
);
2346 if (TARGET_NSIG_WORDS
== 1) {
2347 err
|= __put_user(target_set
.sig
[0],
2348 (abi_ulong
*)&ucp
->tuc_sigmask
);
2350 abi_ulong
*src
, *dst
;
2351 src
= target_set
.sig
;
2352 dst
= ucp
->tuc_sigmask
.sig
;
2353 for (i
= 0; i
< sizeof(target_sigset_t
) / sizeof(abi_ulong
);
2355 err
|= __put_user(*src
, dst
);
2360 /* XXX: tstate must be saved properly */
2361 // err |= __put_user(env->tstate, &((*grp)[MC_TSTATE]));
2362 err
|= __put_user(env
->pc
, &((*grp
)[MC_PC
]));
2363 err
|= __put_user(env
->npc
, &((*grp
)[MC_NPC
]));
2364 err
|= __put_user(env
->y
, &((*grp
)[MC_Y
]));
2365 err
|= __put_user(env
->gregs
[1], &((*grp
)[MC_G1
]));
2366 err
|= __put_user(env
->gregs
[2], &((*grp
)[MC_G2
]));
2367 err
|= __put_user(env
->gregs
[3], &((*grp
)[MC_G3
]));
2368 err
|= __put_user(env
->gregs
[4], &((*grp
)[MC_G4
]));
2369 err
|= __put_user(env
->gregs
[5], &((*grp
)[MC_G5
]));
2370 err
|= __put_user(env
->gregs
[6], &((*grp
)[MC_G6
]));
2371 err
|= __put_user(env
->gregs
[7], &((*grp
)[MC_G7
]));
2372 err
|= __put_user(env
->regwptr
[UREG_I0
], &((*grp
)[MC_O0
]));
2373 err
|= __put_user(env
->regwptr
[UREG_I1
], &((*grp
)[MC_O1
]));
2374 err
|= __put_user(env
->regwptr
[UREG_I2
], &((*grp
)[MC_O2
]));
2375 err
|= __put_user(env
->regwptr
[UREG_I3
], &((*grp
)[MC_O3
]));
2376 err
|= __put_user(env
->regwptr
[UREG_I4
], &((*grp
)[MC_O4
]));
2377 err
|= __put_user(env
->regwptr
[UREG_I5
], &((*grp
)[MC_O5
]));
2378 err
|= __put_user(env
->regwptr
[UREG_I6
], &((*grp
)[MC_O6
]));
2379 err
|= __put_user(env
->regwptr
[UREG_I7
], &((*grp
)[MC_O7
]));
2381 w_addr
= TARGET_STACK_BIAS
+env
->regwptr
[UREG_I6
];
2383 if (get_user(fp
, w_addr
+ offsetof(struct target_reg_window
, ins
[6]),
2386 if (get_user(i7
, w_addr
+ offsetof(struct target_reg_window
, ins
[7]),
2389 err
|= __put_user(fp
, &(mcp
->mc_fp
));
2390 err
|= __put_user(i7
, &(mcp
->mc_i7
));
2393 uint32_t *src
, *dst
;
2395 dst
= ucp
->tuc_mcontext
.mc_fpregs
.mcfpu_fregs
.sregs
;
2396 /* XXX: check that the CPU storage is the same as user context */
2397 for (i
= 0; i
< 64; i
++, dst
++, src
++)
2398 err
|= __put_user(*src
, dst
);
2400 err
|= __put_user(env
->fsr
, &(mcp
->mc_fpregs
.mcfpu_fsr
));
2401 err
|= __put_user(env
->gsr
, &(mcp
->mc_fpregs
.mcfpu_gsr
));
2402 err
|= __put_user(env
->fprs
, &(mcp
->mc_fpregs
.mcfpu_fprs
));
2406 unlock_user_struct(ucp
, ucp_addr
, 1);
2409 unlock_user_struct(ucp
, ucp_addr
, 1);
2410 force_sig(TARGET_SIGSEGV
);
2413 #elif defined(TARGET_ABI_MIPSN64)
2415 # warning signal handling not implemented
2417 static void setup_frame(int sig
, struct target_sigaction
*ka
,
2418 target_sigset_t
*set
, CPUState
*env
)
2420 fprintf(stderr
, "setup_frame: not implemented\n");
2423 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
2424 target_siginfo_t
*info
,
2425 target_sigset_t
*set
, CPUState
*env
)
2427 fprintf(stderr
, "setup_rt_frame: not implemented\n");
2430 long do_sigreturn(CPUState
*env
)
2432 fprintf(stderr
, "do_sigreturn: not implemented\n");
2433 return -TARGET_ENOSYS
;
2436 long do_rt_sigreturn(CPUState
*env
)
2438 fprintf(stderr
, "do_rt_sigreturn: not implemented\n");
2439 return -TARGET_ENOSYS
;
2442 #elif defined(TARGET_ABI_MIPSN32)
2444 # warning signal handling not implemented
2446 static void setup_frame(int sig
, struct target_sigaction
*ka
,
2447 target_sigset_t
*set
, CPUState
*env
)
2449 fprintf(stderr
, "setup_frame: not implemented\n");
2452 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
2453 target_siginfo_t
*info
,
2454 target_sigset_t
*set
, CPUState
*env
)
2456 fprintf(stderr
, "setup_rt_frame: not implemented\n");
2459 long do_sigreturn(CPUState
*env
)
2461 fprintf(stderr
, "do_sigreturn: not implemented\n");
2462 return -TARGET_ENOSYS
;
2465 long do_rt_sigreturn(CPUState
*env
)
2467 fprintf(stderr
, "do_rt_sigreturn: not implemented\n");
2468 return -TARGET_ENOSYS
;
2471 #elif defined(TARGET_ABI_MIPSO32)
2473 struct target_sigcontext
{
2474 uint32_t sc_regmask
; /* Unused */
2477 uint64_t sc_regs
[32];
2478 uint64_t sc_fpregs
[32];
2479 uint32_t sc_ownedfp
; /* Unused */
2480 uint32_t sc_fpc_csr
;
2481 uint32_t sc_fpc_eir
; /* Unused */
2482 uint32_t sc_used_math
;
2483 uint32_t sc_dsp
; /* dsp status, was sc_ssflags */
2487 target_ulong sc_hi1
; /* Was sc_cause */
2488 target_ulong sc_lo1
; /* Was sc_badvaddr */
2489 target_ulong sc_hi2
; /* Was sc_sigset[4] */
2490 target_ulong sc_lo2
;
2491 target_ulong sc_hi3
;
2492 target_ulong sc_lo3
;
2496 uint32_t sf_ass
[4]; /* argument save space for o32 */
2497 uint32_t sf_code
[2]; /* signal trampoline */
2498 struct target_sigcontext sf_sc
;
2499 target_sigset_t sf_mask
;
2502 struct target_ucontext
{
2503 target_ulong tuc_flags
;
2504 target_ulong tuc_link
;
2505 target_stack_t tuc_stack
;
2507 struct target_sigcontext tuc_mcontext
;
2508 target_sigset_t tuc_sigmask
;
2511 struct target_rt_sigframe
{
2512 uint32_t rs_ass
[4]; /* argument save space for o32 */
2513 uint32_t rs_code
[2]; /* signal trampoline */
2514 struct target_siginfo rs_info
;
2515 struct target_ucontext rs_uc
;
2518 /* Install trampoline to jump back from signal handler */
2519 static inline int install_sigtramp(unsigned int *tramp
, unsigned int syscall
)
2524 * Set up the return code ...
2526 * li v0, __NR__foo_sigreturn
2530 err
= __put_user(0x24020000 + syscall
, tramp
+ 0);
2531 err
|= __put_user(0x0000000c , tramp
+ 1);
2532 /* flush_cache_sigtramp((unsigned long) tramp); */
2537 setup_sigcontext(CPUState
*regs
, struct target_sigcontext
*sc
)
2541 err
|= __put_user(regs
->active_tc
.PC
, &sc
->sc_pc
);
2543 #define save_gp_reg(i) do { \
2544 err |= __put_user(regs->active_tc.gpr[i], &sc->sc_regs[i]); \
2546 __put_user(0, &sc
->sc_regs
[0]); save_gp_reg(1); save_gp_reg(2);
2547 save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
2548 save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
2549 save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
2550 save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
2551 save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
2552 save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
2553 save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
2557 err
|= __put_user(regs
->active_tc
.HI
[0], &sc
->sc_mdhi
);
2558 err
|= __put_user(regs
->active_tc
.LO
[0], &sc
->sc_mdlo
);
2560 /* Not used yet, but might be useful if we ever have DSP suppport */
2563 err
|= __put_user(mfhi1(), &sc
->sc_hi1
);
2564 err
|= __put_user(mflo1(), &sc
->sc_lo1
);
2565 err
|= __put_user(mfhi2(), &sc
->sc_hi2
);
2566 err
|= __put_user(mflo2(), &sc
->sc_lo2
);
2567 err
|= __put_user(mfhi3(), &sc
->sc_hi3
);
2568 err
|= __put_user(mflo3(), &sc
->sc_lo3
);
2569 err
|= __put_user(rddsp(DSP_MASK
), &sc
->sc_dsp
);
2571 /* same with 64 bit */
2573 err
|= __put_user(regs
->hi
, &sc
->sc_hi
[0]);
2574 err
|= __put_user(regs
->lo
, &sc
->sc_lo
[0]);
2576 err
|= __put_user(mfhi1(), &sc
->sc_hi
[1]);
2577 err
|= __put_user(mflo1(), &sc
->sc_lo
[1]);
2578 err
|= __put_user(mfhi2(), &sc
->sc_hi
[2]);
2579 err
|= __put_user(mflo2(), &sc
->sc_lo
[2]);
2580 err
|= __put_user(mfhi3(), &sc
->sc_hi
[3]);
2581 err
|= __put_user(mflo3(), &sc
->sc_lo
[3]);
2582 err
|= __put_user(rddsp(DSP_MASK
), &sc
->sc_dsp
);
2588 err
|= __put_user(!!used_math(), &sc
->sc_used_math
);
2594 * Save FPU state to signal context. Signal handler will "inherit"
2595 * current FPU state.
2599 if (!is_fpu_owner()) {
2601 restore_fp(current
);
2603 err
|= save_fp_context(sc
);
2612 restore_sigcontext(CPUState
*regs
, struct target_sigcontext
*sc
)
2616 err
|= __get_user(regs
->CP0_EPC
, &sc
->sc_pc
);
2618 err
|= __get_user(regs
->active_tc
.HI
[0], &sc
->sc_mdhi
);
2619 err
|= __get_user(regs
->active_tc
.LO
[0], &sc
->sc_mdlo
);
2621 #define restore_gp_reg(i) do { \
2622 err |= __get_user(regs->active_tc.gpr[i], &sc->sc_regs[i]); \
2624 restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
2625 restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
2626 restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
2627 restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
2628 restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
2629 restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
2630 restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
2631 restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
2632 restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
2633 restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
2635 #undef restore_gp_reg
2639 err
|= __get_user(treg
, &sc
->sc_hi1
); mthi1(treg
);
2640 err
|= __get_user(treg
, &sc
->sc_lo1
); mtlo1(treg
);
2641 err
|= __get_user(treg
, &sc
->sc_hi2
); mthi2(treg
);
2642 err
|= __get_user(treg
, &sc
->sc_lo2
); mtlo2(treg
);
2643 err
|= __get_user(treg
, &sc
->sc_hi3
); mthi3(treg
);
2644 err
|= __get_user(treg
, &sc
->sc_lo3
); mtlo3(treg
);
2645 err
|= __get_user(treg
, &sc
->sc_dsp
); wrdsp(treg
, DSP_MASK
);
2648 err
|= __get_user(regs
->hi
, &sc
->sc_hi
[0]);
2649 err
|= __get_user(regs
->lo
, &sc
->sc_lo
[0]);
2651 err
|= __get_user(treg
, &sc
->sc_hi
[1]); mthi1(treg
);
2652 err
|= __get_user(treg
, &sc
->sc_lo
[1]); mthi1(treg
);
2653 err
|= __get_user(treg
, &sc
->sc_hi
[2]); mthi2(treg
);
2654 err
|= __get_user(treg
, &sc
->sc_lo
[2]); mthi2(treg
);
2655 err
|= __get_user(treg
, &sc
->sc_hi
[3]); mthi3(treg
);
2656 err
|= __get_user(treg
, &sc
->sc_lo
[3]); mthi3(treg
);
2657 err
|= __get_user(treg
, &sc
->sc_dsp
); wrdsp(treg
, DSP_MASK
);
2661 err
|= __get_user(used_math
, &sc
->sc_used_math
);
2662 conditional_used_math(used_math
);
2667 /* restore fpu context if we have used it before */
2669 err
|= restore_fp_context(sc
);
2671 /* signal handler may have used FPU. Give it up. */
2680 * Determine which stack to use..
2682 static inline abi_ulong
2683 get_sigframe(struct target_sigaction
*ka
, CPUState
*regs
, size_t frame_size
)
2687 /* Default to using normal stack */
2688 sp
= regs
->active_tc
.gpr
[29];
2691 * FPU emulator may have it's own trampoline active just
2692 * above the user stack, 16-bytes before the next lowest
2693 * 16 byte boundary. Try to avoid trashing it.
2697 /* This is the X/Open sanctioned signal stack switching. */
2698 if ((ka
->sa_flags
& TARGET_SA_ONSTACK
) && (sas_ss_flags (sp
) == 0)) {
2699 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
2702 return (sp
- frame_size
) & ~7;
2705 /* compare linux/arch/mips/kernel/signal.c:setup_frame() */
2706 static void setup_frame(int sig
, struct target_sigaction
* ka
,
2707 target_sigset_t
*set
, CPUState
*regs
)
2709 struct sigframe
*frame
;
2710 abi_ulong frame_addr
;
2713 frame_addr
= get_sigframe(ka
, regs
, sizeof(*frame
));
2714 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
2717 install_sigtramp(frame
->sf_code
, TARGET_NR_sigreturn
);
2719 if(setup_sigcontext(regs
, &frame
->sf_sc
))
2722 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
2723 if(__put_user(set
->sig
[i
], &frame
->sf_mask
.sig
[i
]))
2728 * Arguments to signal handler:
2730 * a0 = signal number
2731 * a1 = 0 (should be cause)
2732 * a2 = pointer to struct sigcontext
2734 * $25 and PC point to the signal handler, $29 points to the
2737 regs
->active_tc
.gpr
[ 4] = sig
;
2738 regs
->active_tc
.gpr
[ 5] = 0;
2739 regs
->active_tc
.gpr
[ 6] = frame_addr
+ offsetof(struct sigframe
, sf_sc
);
2740 regs
->active_tc
.gpr
[29] = frame_addr
;
2741 regs
->active_tc
.gpr
[31] = frame_addr
+ offsetof(struct sigframe
, sf_code
);
2742 /* The original kernel code sets CP0_EPC to the handler
2743 * since it returns to userland using eret
2744 * we cannot do this here, and we must set PC directly */
2745 regs
->active_tc
.PC
= regs
->active_tc
.gpr
[25] = ka
->_sa_handler
;
2746 unlock_user_struct(frame
, frame_addr
, 1);
2750 unlock_user_struct(frame
, frame_addr
, 1);
2751 force_sig(TARGET_SIGSEGV
/*, current*/);
2755 long do_sigreturn(CPUState
*regs
)
2757 struct sigframe
*frame
;
2758 abi_ulong frame_addr
;
2760 target_sigset_t target_set
;
2763 #if defined(DEBUG_SIGNAL)
2764 fprintf(stderr
, "do_sigreturn\n");
2766 frame_addr
= regs
->active_tc
.gpr
[29];
2767 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
2770 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
2771 if(__get_user(target_set
.sig
[i
], &frame
->sf_mask
.sig
[i
]))
2775 target_to_host_sigset_internal(&blocked
, &target_set
);
2776 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
2778 if (restore_sigcontext(regs
, &frame
->sf_sc
))
2783 * Don't let your children do this ...
2785 __asm__
__volatile__(
2793 regs
->active_tc
.PC
= regs
->CP0_EPC
;
2794 /* I am not sure this is right, but it seems to work
2795 * maybe a problem with nested signals ? */
2797 return -TARGET_QEMU_ESIGRETURN
;
2800 force_sig(TARGET_SIGSEGV
/*, current*/);
2804 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
2805 target_siginfo_t
*info
,
2806 target_sigset_t
*set
, CPUState
*env
)
2808 struct target_rt_sigframe
*frame
;
2809 abi_ulong frame_addr
;
2812 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
2813 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
2816 install_sigtramp(frame
->rs_code
, TARGET_NR_rt_sigreturn
);
2818 copy_siginfo_to_user(&frame
->rs_info
, info
);
2820 __put_user(0, &frame
->rs_uc
.tuc_flags
);
2821 __put_user(0, &frame
->rs_uc
.tuc_link
);
2822 __put_user(target_sigaltstack_used
.ss_sp
, &frame
->rs_uc
.tuc_stack
.ss_sp
);
2823 __put_user(target_sigaltstack_used
.ss_size
, &frame
->rs_uc
.tuc_stack
.ss_size
);
2824 __put_user(sas_ss_flags(get_sp_from_cpustate(env
)),
2825 &frame
->rs_uc
.tuc_stack
.ss_flags
);
2827 setup_sigcontext(env
, &frame
->rs_uc
.tuc_mcontext
);
2829 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
2830 __put_user(set
->sig
[i
], &frame
->rs_uc
.tuc_sigmask
.sig
[i
]);
2834 * Arguments to signal handler:
2836 * a0 = signal number
2837 * a1 = pointer to struct siginfo
2838 * a2 = pointer to struct ucontext
2840 * $25 and PC point to the signal handler, $29 points to the
2843 env
->active_tc
.gpr
[ 4] = sig
;
2844 env
->active_tc
.gpr
[ 5] = frame_addr
2845 + offsetof(struct target_rt_sigframe
, rs_info
);
2846 env
->active_tc
.gpr
[ 6] = frame_addr
2847 + offsetof(struct target_rt_sigframe
, rs_uc
);
2848 env
->active_tc
.gpr
[29] = frame_addr
;
2849 env
->active_tc
.gpr
[31] = frame_addr
2850 + offsetof(struct target_rt_sigframe
, rs_code
);
2851 /* The original kernel code sets CP0_EPC to the handler
2852 * since it returns to userland using eret
2853 * we cannot do this here, and we must set PC directly */
2854 env
->active_tc
.PC
= env
->active_tc
.gpr
[25] = ka
->_sa_handler
;
2855 unlock_user_struct(frame
, frame_addr
, 1);
2859 unlock_user_struct(frame
, frame_addr
, 1);
2860 force_sig(TARGET_SIGSEGV
/*, current*/);
2864 long do_rt_sigreturn(CPUState
*env
)
2866 struct target_rt_sigframe
*frame
;
2867 abi_ulong frame_addr
;
2870 #if defined(DEBUG_SIGNAL)
2871 fprintf(stderr
, "do_rt_sigreturn\n");
2873 frame_addr
= env
->active_tc
.gpr
[29];
2874 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
2877 target_to_host_sigset(&blocked
, &frame
->rs_uc
.tuc_sigmask
);
2878 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
2880 if (restore_sigcontext(env
, &frame
->rs_uc
.tuc_mcontext
))
2883 if (do_sigaltstack(frame_addr
+
2884 offsetof(struct target_rt_sigframe
, rs_uc
.tuc_stack
),
2885 0, get_sp_from_cpustate(env
)) == -EFAULT
)
2888 env
->active_tc
.PC
= env
->CP0_EPC
;
2889 /* I am not sure this is right, but it seems to work
2890 * maybe a problem with nested signals ? */
2892 return -TARGET_QEMU_ESIGRETURN
;
2895 force_sig(TARGET_SIGSEGV
/*, current*/);
2899 #elif defined(TARGET_SH4)
2902 * code and data structures from linux kernel:
2903 * include/asm-sh/sigcontext.h
2904 * arch/sh/kernel/signal.c
2907 struct target_sigcontext
{
2908 target_ulong oldmask
;
2911 target_ulong sc_gregs
[16];
2915 target_ulong sc_gbr
;
2916 target_ulong sc_mach
;
2917 target_ulong sc_macl
;
2920 target_ulong sc_fpregs
[16];
2921 target_ulong sc_xfpregs
[16];
2922 unsigned int sc_fpscr
;
2923 unsigned int sc_fpul
;
2924 unsigned int sc_ownedfp
;
2927 struct target_sigframe
2929 struct target_sigcontext sc
;
2930 target_ulong extramask
[TARGET_NSIG_WORDS
-1];
2931 uint16_t retcode
[3];
2935 struct target_ucontext
{
2936 target_ulong tuc_flags
;
2937 struct target_ucontext
*tuc_link
;
2938 target_stack_t tuc_stack
;
2939 struct target_sigcontext tuc_mcontext
;
2940 target_sigset_t tuc_sigmask
; /* mask last for extensibility */
2943 struct target_rt_sigframe
2945 struct target_siginfo info
;
2946 struct target_ucontext uc
;
2947 uint16_t retcode
[3];
2951 #define MOVW(n) (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */
2952 #define TRAP_NOARG 0xc310 /* Syscall w/no args (NR in R3) SH3/4 */
2954 static abi_ulong
get_sigframe(struct target_sigaction
*ka
,
2955 unsigned long sp
, size_t frame_size
)
2957 if ((ka
->sa_flags
& TARGET_SA_ONSTACK
) && (sas_ss_flags(sp
) == 0)) {
2958 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
2961 return (sp
- frame_size
) & -8ul;
2964 static int setup_sigcontext(struct target_sigcontext
*sc
,
2965 CPUState
*regs
, unsigned long mask
)
2970 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
2971 COPY(gregs
[0]); COPY(gregs
[1]);
2972 COPY(gregs
[2]); COPY(gregs
[3]);
2973 COPY(gregs
[4]); COPY(gregs
[5]);
2974 COPY(gregs
[6]); COPY(gregs
[7]);
2975 COPY(gregs
[8]); COPY(gregs
[9]);
2976 COPY(gregs
[10]); COPY(gregs
[11]);
2977 COPY(gregs
[12]); COPY(gregs
[13]);
2978 COPY(gregs
[14]); COPY(gregs
[15]);
2979 COPY(gbr
); COPY(mach
);
2980 COPY(macl
); COPY(pr
);
2984 for (i
=0; i
<16; i
++) {
2985 err
|= __put_user(regs
->fregs
[i
], &sc
->sc_fpregs
[i
]);
2987 err
|= __put_user(regs
->fpscr
, &sc
->sc_fpscr
);
2988 err
|= __put_user(regs
->fpul
, &sc
->sc_fpul
);
2990 /* non-iBCS2 extensions.. */
2991 err
|= __put_user(mask
, &sc
->oldmask
);
2996 static int restore_sigcontext(CPUState
*regs
, struct target_sigcontext
*sc
,
2999 unsigned int err
= 0;
3002 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
3004 COPY(gregs
[2]); COPY(gregs
[3]);
3005 COPY(gregs
[4]); COPY(gregs
[5]);
3006 COPY(gregs
[6]); COPY(gregs
[7]);
3007 COPY(gregs
[8]); COPY(gregs
[9]);
3008 COPY(gregs
[10]); COPY(gregs
[11]);
3009 COPY(gregs
[12]); COPY(gregs
[13]);
3010 COPY(gregs
[14]); COPY(gregs
[15]);
3011 COPY(gbr
); COPY(mach
);
3012 COPY(macl
); COPY(pr
);
3016 for (i
=0; i
<16; i
++) {
3017 err
|= __get_user(regs
->fregs
[i
], &sc
->sc_fpregs
[i
]);
3019 err
|= __get_user(regs
->fpscr
, &sc
->sc_fpscr
);
3020 err
|= __get_user(regs
->fpul
, &sc
->sc_fpul
);
3022 regs
->tra
= -1; /* disable syscall checks */
3023 err
|= __get_user(*r0_p
, &sc
->sc_gregs
[0]);
3027 static void setup_frame(int sig
, struct target_sigaction
*ka
,
3028 target_sigset_t
*set
, CPUState
*regs
)
3030 struct target_sigframe
*frame
;
3031 abi_ulong frame_addr
;
3036 frame_addr
= get_sigframe(ka
, regs
->gregs
[15], sizeof(*frame
));
3037 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
3040 signal
= current_exec_domain_sig(sig
);
3042 err
|= setup_sigcontext(&frame
->sc
, regs
, set
->sig
[0]);
3044 for (i
= 0; i
< TARGET_NSIG_WORDS
- 1; i
++) {
3045 err
|= __put_user(set
->sig
[i
+ 1], &frame
->extramask
[i
]);
3048 /* Set up to return from userspace. If provided, use a stub
3049 already in userspace. */
3050 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
3051 regs
->pr
= (unsigned long) ka
->sa_restorer
;
3053 /* Generate return code (system call to sigreturn) */
3054 err
|= __put_user(MOVW(2), &frame
->retcode
[0]);
3055 err
|= __put_user(TRAP_NOARG
, &frame
->retcode
[1]);
3056 err
|= __put_user((TARGET_NR_sigreturn
), &frame
->retcode
[2]);
3057 regs
->pr
= (unsigned long) frame
->retcode
;
3063 /* Set up registers for signal handler */
3064 regs
->gregs
[15] = frame_addr
;
3065 regs
->gregs
[4] = signal
; /* Arg for signal handler */
3067 regs
->gregs
[6] = frame_addr
+= offsetof(typeof(*frame
), sc
);
3068 regs
->pc
= (unsigned long) ka
->_sa_handler
;
3070 unlock_user_struct(frame
, frame_addr
, 1);
3074 unlock_user_struct(frame
, frame_addr
, 1);
3075 force_sig(TARGET_SIGSEGV
);
3078 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
3079 target_siginfo_t
*info
,
3080 target_sigset_t
*set
, CPUState
*regs
)
3082 struct target_rt_sigframe
*frame
;
3083 abi_ulong frame_addr
;
3088 frame_addr
= get_sigframe(ka
, regs
->gregs
[15], sizeof(*frame
));
3089 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
3092 signal
= current_exec_domain_sig(sig
);
3094 err
|= copy_siginfo_to_user(&frame
->info
, info
);
3096 /* Create the ucontext. */
3097 err
|= __put_user(0, &frame
->uc
.tuc_flags
);
3098 err
|= __put_user(0, (unsigned long *)&frame
->uc
.tuc_link
);
3099 err
|= __put_user((unsigned long)target_sigaltstack_used
.ss_sp
,
3100 &frame
->uc
.tuc_stack
.ss_sp
);
3101 err
|= __put_user(sas_ss_flags(regs
->gregs
[15]),
3102 &frame
->uc
.tuc_stack
.ss_flags
);
3103 err
|= __put_user(target_sigaltstack_used
.ss_size
,
3104 &frame
->uc
.tuc_stack
.ss_size
);
3105 err
|= setup_sigcontext(&frame
->uc
.tuc_mcontext
,
3107 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
3108 err
|= __put_user(set
->sig
[i
], &frame
->uc
.tuc_sigmask
.sig
[i
]);
3111 /* Set up to return from userspace. If provided, use a stub
3112 already in userspace. */
3113 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
3114 regs
->pr
= (unsigned long) ka
->sa_restorer
;
3116 /* Generate return code (system call to sigreturn) */
3117 err
|= __put_user(MOVW(2), &frame
->retcode
[0]);
3118 err
|= __put_user(TRAP_NOARG
, &frame
->retcode
[1]);
3119 err
|= __put_user((TARGET_NR_rt_sigreturn
), &frame
->retcode
[2]);
3120 regs
->pr
= (unsigned long) frame
->retcode
;
3126 /* Set up registers for signal handler */
3127 regs
->gregs
[15] = frame_addr
;
3128 regs
->gregs
[4] = signal
; /* Arg for signal handler */
3129 regs
->gregs
[5] = frame_addr
+ offsetof(typeof(*frame
), info
);
3130 regs
->gregs
[6] = frame_addr
+ offsetof(typeof(*frame
), uc
);
3131 regs
->pc
= (unsigned long) ka
->_sa_handler
;
3133 unlock_user_struct(frame
, frame_addr
, 1);
3137 unlock_user_struct(frame
, frame_addr
, 1);
3138 force_sig(TARGET_SIGSEGV
);
3141 long do_sigreturn(CPUState
*regs
)
3143 struct target_sigframe
*frame
;
3144 abi_ulong frame_addr
;
3146 target_sigset_t target_set
;
3151 #if defined(DEBUG_SIGNAL)
3152 fprintf(stderr
, "do_sigreturn\n");
3154 frame_addr
= regs
->gregs
[15];
3155 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
3158 err
|= __get_user(target_set
.sig
[0], &frame
->sc
.oldmask
);
3159 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
3160 err
|= (__get_user(target_set
.sig
[i
], &frame
->extramask
[i
- 1]));
3166 target_to_host_sigset_internal(&blocked
, &target_set
);
3167 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
3169 if (restore_sigcontext(regs
, &frame
->sc
, &r0
))
3172 unlock_user_struct(frame
, frame_addr
, 0);
3176 unlock_user_struct(frame
, frame_addr
, 0);
3177 force_sig(TARGET_SIGSEGV
);
3181 long do_rt_sigreturn(CPUState
*regs
)
3183 struct target_rt_sigframe
*frame
;
3184 abi_ulong frame_addr
;
3188 #if defined(DEBUG_SIGNAL)
3189 fprintf(stderr
, "do_rt_sigreturn\n");
3191 frame_addr
= regs
->gregs
[15];
3192 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
3195 target_to_host_sigset(&blocked
, &frame
->uc
.tuc_sigmask
);
3196 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
3198 if (restore_sigcontext(regs
, &frame
->uc
.tuc_mcontext
, &r0
))
3201 if (do_sigaltstack(frame_addr
+
3202 offsetof(struct target_rt_sigframe
, uc
.tuc_stack
),
3203 0, get_sp_from_cpustate(regs
)) == -EFAULT
)
3206 unlock_user_struct(frame
, frame_addr
, 0);
3210 unlock_user_struct(frame
, frame_addr
, 0);
3211 force_sig(TARGET_SIGSEGV
);
3214 #elif defined(TARGET_MICROBLAZE)
3216 struct target_sigcontext
{
3217 struct target_pt_regs regs
; /* needs to be first */
3221 struct target_stack_t
{
3224 unsigned int ss_size
;
3227 struct target_ucontext
{
3228 abi_ulong tuc_flags
;
3230 struct target_stack_t tuc_stack
;
3231 struct target_sigcontext tuc_mcontext
;
3232 uint32_t tuc_extramask
[TARGET_NSIG_WORDS
- 1];
3235 /* Signal frames. */
3236 struct target_signal_frame
{
3237 struct target_ucontext uc
;
3238 uint32_t extramask
[TARGET_NSIG_WORDS
- 1];
3242 struct rt_signal_frame
{
3243 struct siginfo info
;
3248 static void setup_sigcontext(struct target_sigcontext
*sc
, CPUState
*env
)
3250 __put_user(env
->regs
[0], &sc
->regs
.r0
);
3251 __put_user(env
->regs
[1], &sc
->regs
.r1
);
3252 __put_user(env
->regs
[2], &sc
->regs
.r2
);
3253 __put_user(env
->regs
[3], &sc
->regs
.r3
);
3254 __put_user(env
->regs
[4], &sc
->regs
.r4
);
3255 __put_user(env
->regs
[5], &sc
->regs
.r5
);
3256 __put_user(env
->regs
[6], &sc
->regs
.r6
);
3257 __put_user(env
->regs
[7], &sc
->regs
.r7
);
3258 __put_user(env
->regs
[8], &sc
->regs
.r8
);
3259 __put_user(env
->regs
[9], &sc
->regs
.r9
);
3260 __put_user(env
->regs
[10], &sc
->regs
.r10
);
3261 __put_user(env
->regs
[11], &sc
->regs
.r11
);
3262 __put_user(env
->regs
[12], &sc
->regs
.r12
);
3263 __put_user(env
->regs
[13], &sc
->regs
.r13
);
3264 __put_user(env
->regs
[14], &sc
->regs
.r14
);
3265 __put_user(env
->regs
[15], &sc
->regs
.r15
);
3266 __put_user(env
->regs
[16], &sc
->regs
.r16
);
3267 __put_user(env
->regs
[17], &sc
->regs
.r17
);
3268 __put_user(env
->regs
[18], &sc
->regs
.r18
);
3269 __put_user(env
->regs
[19], &sc
->regs
.r19
);
3270 __put_user(env
->regs
[20], &sc
->regs
.r20
);
3271 __put_user(env
->regs
[21], &sc
->regs
.r21
);
3272 __put_user(env
->regs
[22], &sc
->regs
.r22
);
3273 __put_user(env
->regs
[23], &sc
->regs
.r23
);
3274 __put_user(env
->regs
[24], &sc
->regs
.r24
);
3275 __put_user(env
->regs
[25], &sc
->regs
.r25
);
3276 __put_user(env
->regs
[26], &sc
->regs
.r26
);
3277 __put_user(env
->regs
[27], &sc
->regs
.r27
);
3278 __put_user(env
->regs
[28], &sc
->regs
.r28
);
3279 __put_user(env
->regs
[29], &sc
->regs
.r29
);
3280 __put_user(env
->regs
[30], &sc
->regs
.r30
);
3281 __put_user(env
->regs
[31], &sc
->regs
.r31
);
3282 __put_user(env
->sregs
[SR_PC
], &sc
->regs
.pc
);
3285 static void restore_sigcontext(struct target_sigcontext
*sc
, CPUState
*env
)
3287 __get_user(env
->regs
[0], &sc
->regs
.r0
);
3288 __get_user(env
->regs
[1], &sc
->regs
.r1
);
3289 __get_user(env
->regs
[2], &sc
->regs
.r2
);
3290 __get_user(env
->regs
[3], &sc
->regs
.r3
);
3291 __get_user(env
->regs
[4], &sc
->regs
.r4
);
3292 __get_user(env
->regs
[5], &sc
->regs
.r5
);
3293 __get_user(env
->regs
[6], &sc
->regs
.r6
);
3294 __get_user(env
->regs
[7], &sc
->regs
.r7
);
3295 __get_user(env
->regs
[8], &sc
->regs
.r8
);
3296 __get_user(env
->regs
[9], &sc
->regs
.r9
);
3297 __get_user(env
->regs
[10], &sc
->regs
.r10
);
3298 __get_user(env
->regs
[11], &sc
->regs
.r11
);
3299 __get_user(env
->regs
[12], &sc
->regs
.r12
);
3300 __get_user(env
->regs
[13], &sc
->regs
.r13
);
3301 __get_user(env
->regs
[14], &sc
->regs
.r14
);
3302 __get_user(env
->regs
[15], &sc
->regs
.r15
);
3303 __get_user(env
->regs
[16], &sc
->regs
.r16
);
3304 __get_user(env
->regs
[17], &sc
->regs
.r17
);
3305 __get_user(env
->regs
[18], &sc
->regs
.r18
);
3306 __get_user(env
->regs
[19], &sc
->regs
.r19
);
3307 __get_user(env
->regs
[20], &sc
->regs
.r20
);
3308 __get_user(env
->regs
[21], &sc
->regs
.r21
);
3309 __get_user(env
->regs
[22], &sc
->regs
.r22
);
3310 __get_user(env
->regs
[23], &sc
->regs
.r23
);
3311 __get_user(env
->regs
[24], &sc
->regs
.r24
);
3312 __get_user(env
->regs
[25], &sc
->regs
.r25
);
3313 __get_user(env
->regs
[26], &sc
->regs
.r26
);
3314 __get_user(env
->regs
[27], &sc
->regs
.r27
);
3315 __get_user(env
->regs
[28], &sc
->regs
.r28
);
3316 __get_user(env
->regs
[29], &sc
->regs
.r29
);
3317 __get_user(env
->regs
[30], &sc
->regs
.r30
);
3318 __get_user(env
->regs
[31], &sc
->regs
.r31
);
3319 __get_user(env
->sregs
[SR_PC
], &sc
->regs
.pc
);
3322 static abi_ulong
get_sigframe(struct target_sigaction
*ka
,
3323 CPUState
*env
, int frame_size
)
3325 abi_ulong sp
= env
->regs
[1];
3327 if ((ka
->sa_flags
& SA_ONSTACK
) != 0 && !on_sig_stack(sp
))
3328 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
3330 return ((sp
- frame_size
) & -8UL);
3333 static void setup_frame(int sig
, struct target_sigaction
*ka
,
3334 target_sigset_t
*set
, CPUState
*env
)
3336 struct target_signal_frame
*frame
;
3337 abi_ulong frame_addr
;
3341 frame_addr
= get_sigframe(ka
, env
, sizeof *frame
);
3342 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
3345 /* Save the mask. */
3346 err
|= __put_user(set
->sig
[0], &frame
->uc
.tuc_mcontext
.oldmask
);
3350 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
3351 if (__put_user(set
->sig
[i
], &frame
->extramask
[i
- 1]))
3355 setup_sigcontext(&frame
->uc
.tuc_mcontext
, env
);
3357 /* Set up to return from userspace. If provided, use a stub
3358 already in userspace. */
3359 /* minus 8 is offset to cater for "rtsd r15,8" offset */
3360 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
3361 env
->regs
[15] = ((unsigned long)ka
->sa_restorer
)-8;
3364 /* Note, these encodings are _big endian_! */
3365 /* addi r12, r0, __NR_sigreturn */
3366 t
= 0x31800000UL
| TARGET_NR_sigreturn
;
3367 err
|= __put_user(t
, frame
->tramp
+ 0);
3370 err
|= __put_user(t
, frame
->tramp
+ 1);
3372 /* Return from sighandler will jump to the tramp.
3373 Negative 8 offset because return is rtsd r15, 8 */
3374 env
->regs
[15] = ((unsigned long)frame
->tramp
) - 8;
3380 /* Set up registers for signal handler */
3381 env
->regs
[1] = frame_addr
;
3382 /* Signal handler args: */
3383 env
->regs
[5] = sig
; /* Arg 0: signum */
3385 /* arg 1: sigcontext */
3386 env
->regs
[7] = frame_addr
+= offsetof(typeof(*frame
), uc
);
3388 /* Offset of 4 to handle microblaze rtid r14, 0 */
3389 env
->sregs
[SR_PC
] = (unsigned long)ka
->_sa_handler
;
3391 unlock_user_struct(frame
, frame_addr
, 1);
3394 unlock_user_struct(frame
, frame_addr
, 1);
3395 force_sig(TARGET_SIGSEGV
);
3398 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
3399 target_siginfo_t
*info
,
3400 target_sigset_t
*set
, CPUState
*env
)
3402 fprintf(stderr
, "Microblaze setup_rt_frame: not implemented\n");
3405 long do_sigreturn(CPUState
*env
)
3407 struct target_signal_frame
*frame
;
3408 abi_ulong frame_addr
;
3409 target_sigset_t target_set
;
3413 frame_addr
= env
->regs
[R_SP
];
3414 /* Make sure the guest isn't playing games. */
3415 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 1))
3418 /* Restore blocked signals */
3419 if (__get_user(target_set
.sig
[0], &frame
->uc
.tuc_mcontext
.oldmask
))
3421 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
3422 if (__get_user(target_set
.sig
[i
], &frame
->extramask
[i
- 1]))
3425 target_to_host_sigset_internal(&set
, &target_set
);
3426 sigprocmask(SIG_SETMASK
, &set
, NULL
);
3428 restore_sigcontext(&frame
->uc
.tuc_mcontext
, env
);
3429 /* We got here through a sigreturn syscall, our path back is via an
3430 rtb insn so setup r14 for that. */
3431 env
->regs
[14] = env
->sregs
[SR_PC
];
3433 unlock_user_struct(frame
, frame_addr
, 0);
3434 return env
->regs
[10];
3436 unlock_user_struct(frame
, frame_addr
, 0);
3437 force_sig(TARGET_SIGSEGV
);
3440 long do_rt_sigreturn(CPUState
*env
)
3442 fprintf(stderr
, "Microblaze do_rt_sigreturn: not implemented\n");
3443 return -TARGET_ENOSYS
;
3446 #elif defined(TARGET_CRIS)
3448 struct target_sigcontext
{
3449 struct target_pt_regs regs
; /* needs to be first */
3451 uint32_t usp
; /* usp before stacking this gunk on it */
3454 /* Signal frames. */
3455 struct target_signal_frame
{
3456 struct target_sigcontext sc
;
3457 uint32_t extramask
[TARGET_NSIG_WORDS
- 1];
3458 uint8_t retcode
[8]; /* Trampoline code. */
3461 struct rt_signal_frame
{
3462 struct siginfo
*pinfo
;
3464 struct siginfo info
;
3466 uint8_t retcode
[8]; /* Trampoline code. */
3469 static void setup_sigcontext(struct target_sigcontext
*sc
, CPUState
*env
)
3471 __put_user(env
->regs
[0], &sc
->regs
.r0
);
3472 __put_user(env
->regs
[1], &sc
->regs
.r1
);
3473 __put_user(env
->regs
[2], &sc
->regs
.r2
);
3474 __put_user(env
->regs
[3], &sc
->regs
.r3
);
3475 __put_user(env
->regs
[4], &sc
->regs
.r4
);
3476 __put_user(env
->regs
[5], &sc
->regs
.r5
);
3477 __put_user(env
->regs
[6], &sc
->regs
.r6
);
3478 __put_user(env
->regs
[7], &sc
->regs
.r7
);
3479 __put_user(env
->regs
[8], &sc
->regs
.r8
);
3480 __put_user(env
->regs
[9], &sc
->regs
.r9
);
3481 __put_user(env
->regs
[10], &sc
->regs
.r10
);
3482 __put_user(env
->regs
[11], &sc
->regs
.r11
);
3483 __put_user(env
->regs
[12], &sc
->regs
.r12
);
3484 __put_user(env
->regs
[13], &sc
->regs
.r13
);
3485 __put_user(env
->regs
[14], &sc
->usp
);
3486 __put_user(env
->regs
[15], &sc
->regs
.acr
);
3487 __put_user(env
->pregs
[PR_MOF
], &sc
->regs
.mof
);
3488 __put_user(env
->pregs
[PR_SRP
], &sc
->regs
.srp
);
3489 __put_user(env
->pc
, &sc
->regs
.erp
);
3492 static void restore_sigcontext(struct target_sigcontext
*sc
, CPUState
*env
)
3494 __get_user(env
->regs
[0], &sc
->regs
.r0
);
3495 __get_user(env
->regs
[1], &sc
->regs
.r1
);
3496 __get_user(env
->regs
[2], &sc
->regs
.r2
);
3497 __get_user(env
->regs
[3], &sc
->regs
.r3
);
3498 __get_user(env
->regs
[4], &sc
->regs
.r4
);
3499 __get_user(env
->regs
[5], &sc
->regs
.r5
);
3500 __get_user(env
->regs
[6], &sc
->regs
.r6
);
3501 __get_user(env
->regs
[7], &sc
->regs
.r7
);
3502 __get_user(env
->regs
[8], &sc
->regs
.r8
);
3503 __get_user(env
->regs
[9], &sc
->regs
.r9
);
3504 __get_user(env
->regs
[10], &sc
->regs
.r10
);
3505 __get_user(env
->regs
[11], &sc
->regs
.r11
);
3506 __get_user(env
->regs
[12], &sc
->regs
.r12
);
3507 __get_user(env
->regs
[13], &sc
->regs
.r13
);
3508 __get_user(env
->regs
[14], &sc
->usp
);
3509 __get_user(env
->regs
[15], &sc
->regs
.acr
);
3510 __get_user(env
->pregs
[PR_MOF
], &sc
->regs
.mof
);
3511 __get_user(env
->pregs
[PR_SRP
], &sc
->regs
.srp
);
3512 __get_user(env
->pc
, &sc
->regs
.erp
);
3515 static abi_ulong
get_sigframe(CPUState
*env
, int framesize
)
3518 /* Align the stack downwards to 4. */
3519 sp
= (env
->regs
[R_SP
] & ~3);
3520 return sp
- framesize
;
3523 static void setup_frame(int sig
, struct target_sigaction
*ka
,
3524 target_sigset_t
*set
, CPUState
*env
)
3526 struct target_signal_frame
*frame
;
3527 abi_ulong frame_addr
;
3531 frame_addr
= get_sigframe(env
, sizeof *frame
);
3532 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
3536 * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't
3537 * use this trampoline anymore but it sets it up for GDB.
3538 * In QEMU, using the trampoline simplifies things a bit so we use it.
3540 * This is movu.w __NR_sigreturn, r9; break 13;
3542 err
|= __put_user(0x9c5f, frame
->retcode
+0);
3543 err
|= __put_user(TARGET_NR_sigreturn
,
3545 err
|= __put_user(0xe93d, frame
->retcode
+4);
3547 /* Save the mask. */
3548 err
|= __put_user(set
->sig
[0], &frame
->sc
.oldmask
);
3552 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
3553 if (__put_user(set
->sig
[i
], &frame
->extramask
[i
- 1]))
3557 setup_sigcontext(&frame
->sc
, env
);
3559 /* Move the stack and setup the arguments for the handler. */
3560 env
->regs
[R_SP
] = frame_addr
;
3561 env
->regs
[10] = sig
;
3562 env
->pc
= (unsigned long) ka
->_sa_handler
;
3563 /* Link SRP so the guest returns through the trampoline. */
3564 env
->pregs
[PR_SRP
] = frame_addr
+ offsetof(typeof(*frame
), retcode
);
3566 unlock_user_struct(frame
, frame_addr
, 1);
3569 unlock_user_struct(frame
, frame_addr
, 1);
3570 force_sig(TARGET_SIGSEGV
);
3573 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
3574 target_siginfo_t
*info
,
3575 target_sigset_t
*set
, CPUState
*env
)
3577 fprintf(stderr
, "CRIS setup_rt_frame: not implemented\n");
3580 long do_sigreturn(CPUState
*env
)
3582 struct target_signal_frame
*frame
;
3583 abi_ulong frame_addr
;
3584 target_sigset_t target_set
;
3588 frame_addr
= env
->regs
[R_SP
];
3589 /* Make sure the guest isn't playing games. */
3590 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 1))
3593 /* Restore blocked signals */
3594 if (__get_user(target_set
.sig
[0], &frame
->sc
.oldmask
))
3596 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
3597 if (__get_user(target_set
.sig
[i
], &frame
->extramask
[i
- 1]))
3600 target_to_host_sigset_internal(&set
, &target_set
);
3601 sigprocmask(SIG_SETMASK
, &set
, NULL
);
3603 restore_sigcontext(&frame
->sc
, env
);
3604 unlock_user_struct(frame
, frame_addr
, 0);
3605 return env
->regs
[10];
3607 unlock_user_struct(frame
, frame_addr
, 0);
3608 force_sig(TARGET_SIGSEGV
);
3611 long do_rt_sigreturn(CPUState
*env
)
3613 fprintf(stderr
, "CRIS do_rt_sigreturn: not implemented\n");
3614 return -TARGET_ENOSYS
;
3617 #elif defined(TARGET_S390X)
3619 #define __NUM_GPRS 16
3620 #define __NUM_FPRS 16
3621 #define __NUM_ACRS 16
3623 #define S390_SYSCALL_SIZE 2
3624 #define __SIGNAL_FRAMESIZE 160 /* FIXME: 31-bit mode -> 96 */
3626 #define _SIGCONTEXT_NSIG 64
3627 #define _SIGCONTEXT_NSIG_BPW 64 /* FIXME: 31-bit mode -> 32 */
3628 #define _SIGCONTEXT_NSIG_WORDS (_SIGCONTEXT_NSIG / _SIGCONTEXT_NSIG_BPW)
3629 #define _SIGMASK_COPY_SIZE (sizeof(unsigned long)*_SIGCONTEXT_NSIG_WORDS)
3630 #define PSW_ADDR_AMODE 0x0000000000000000UL /* 0x80000000UL for 31-bit */
3631 #define S390_SYSCALL_OPCODE ((uint16_t)0x0a00)
3635 target_ulong gprs
[__NUM_GPRS
];
3636 unsigned int acrs
[__NUM_ACRS
];
3637 } target_s390_regs_common
;
3641 double fprs
[__NUM_FPRS
];
3642 } target_s390_fp_regs
;
3645 target_s390_regs_common regs
;
3646 target_s390_fp_regs fpregs
;
3649 struct target_sigcontext
{
3650 target_ulong oldmask
[_SIGCONTEXT_NSIG_WORDS
];
3651 target_sigregs
*sregs
;
3655 uint8_t callee_used_stack
[__SIGNAL_FRAMESIZE
];
3656 struct target_sigcontext sc
;
3657 target_sigregs sregs
;
3659 uint8_t retcode
[S390_SYSCALL_SIZE
];
3662 struct target_ucontext
{
3663 target_ulong tuc_flags
;
3664 struct target_ucontext
*tuc_link
;
3665 target_stack_t tuc_stack
;
3666 target_sigregs tuc_mcontext
;
3667 target_sigset_t tuc_sigmask
; /* mask last for extensibility */
3671 uint8_t callee_used_stack
[__SIGNAL_FRAMESIZE
];
3672 uint8_t retcode
[S390_SYSCALL_SIZE
];
3673 struct target_siginfo info
;
3674 struct target_ucontext uc
;
3677 static inline abi_ulong
3678 get_sigframe(struct target_sigaction
*ka
, CPUState
*env
, size_t frame_size
)
3682 /* Default to using normal stack */
3685 /* This is the X/Open sanctioned signal stack switching. */
3686 if (ka
->sa_flags
& TARGET_SA_ONSTACK
) {
3687 if (!sas_ss_flags(sp
)) {
3688 sp
= target_sigaltstack_used
.ss_sp
+
3689 target_sigaltstack_used
.ss_size
;
3693 /* This is the legacy signal stack switching. */
3694 else if (/* FIXME !user_mode(regs) */ 0 &&
3695 !(ka
->sa_flags
& TARGET_SA_RESTORER
) &&
3697 sp
= (abi_ulong
) ka
->sa_restorer
;
3700 return (sp
- frame_size
) & -8ul;
3703 static void save_sigregs(CPUState
*env
, target_sigregs
*sregs
)
3706 //save_access_regs(current->thread.acrs); FIXME
3708 /* Copy a 'clean' PSW mask to the user to avoid leaking
3709 information about whether PER is currently on. */
3710 __put_user(env
->psw
.mask
, &sregs
->regs
.psw
.mask
);
3711 __put_user(env
->psw
.addr
, &sregs
->regs
.psw
.addr
);
3712 for (i
= 0; i
< 16; i
++) {
3713 __put_user(env
->regs
[i
], &sregs
->regs
.gprs
[i
]);
3715 for (i
= 0; i
< 16; i
++) {
3716 __put_user(env
->aregs
[i
], &sregs
->regs
.acrs
[i
]);
3719 * We have to store the fp registers to current->thread.fp_regs
3720 * to merge them with the emulated registers.
3722 //save_fp_regs(¤t->thread.fp_regs); FIXME
3723 for (i
= 0; i
< 16; i
++) {
3724 __put_user(env
->fregs
[i
].ll
, &sregs
->fpregs
.fprs
[i
]);
3728 static void setup_frame(int sig
, struct target_sigaction
*ka
,
3729 target_sigset_t
*set
, CPUState
*env
)
3732 abi_ulong frame_addr
;
3734 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
3735 qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__
,
3736 (unsigned long long)frame_addr
);
3737 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0)) {
3741 qemu_log("%s: 1\n", __FUNCTION__
);
3742 if (__put_user(set
->sig
[0], &frame
->sc
.oldmask
[0])) {
3746 save_sigregs(env
, &frame
->sregs
);
3748 __put_user((abi_ulong
)(unsigned long)&frame
->sregs
,
3749 (abi_ulong
*)&frame
->sc
.sregs
);
3751 /* Set up to return from userspace. If provided, use a stub
3752 already in userspace. */
3753 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
3754 env
->regs
[14] = (unsigned long)
3755 ka
->sa_restorer
| PSW_ADDR_AMODE
;
3757 env
->regs
[14] = (unsigned long)
3758 frame
->retcode
| PSW_ADDR_AMODE
;
3759 if (__put_user(S390_SYSCALL_OPCODE
| TARGET_NR_sigreturn
,
3760 (uint16_t *)(frame
->retcode
)))
3764 /* Set up backchain. */
3765 if (__put_user(env
->regs
[15], (abi_ulong
*) frame
)) {
3769 /* Set up registers for signal handler */
3770 env
->regs
[15] = frame_addr
;
3771 env
->psw
.addr
= (target_ulong
) ka
->_sa_handler
| PSW_ADDR_AMODE
;
3773 env
->regs
[2] = sig
; //map_signal(sig);
3774 env
->regs
[3] = frame_addr
+= offsetof(typeof(*frame
), sc
);
3776 /* We forgot to include these in the sigcontext.
3777 To avoid breaking binary compatibility, they are passed as args. */
3778 env
->regs
[4] = 0; // FIXME: no clue... current->thread.trap_no;
3779 env
->regs
[5] = 0; // FIXME: no clue... current->thread.prot_addr;
3781 /* Place signal number on stack to allow backtrace from handler. */
3782 if (__put_user(env
->regs
[2], (int *) &frame
->signo
)) {
3785 unlock_user_struct(frame
, frame_addr
, 1);
3789 qemu_log("%s: give_sigsegv\n", __FUNCTION__
);
3790 unlock_user_struct(frame
, frame_addr
, 1);
3791 force_sig(TARGET_SIGSEGV
);
3794 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
3795 target_siginfo_t
*info
,
3796 target_sigset_t
*set
, CPUState
*env
)
3800 abi_ulong frame_addr
;
3802 frame_addr
= get_sigframe(ka
, env
, sizeof *frame
);
3803 qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__
,
3804 (unsigned long long)frame_addr
);
3805 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0)) {
3809 qemu_log("%s: 1\n", __FUNCTION__
);
3810 if (copy_siginfo_to_user(&frame
->info
, info
)) {
3814 /* Create the ucontext. */
3815 __put_user(0, &frame
->uc
.tuc_flags
);
3816 __put_user((abi_ulong
)0, (abi_ulong
*)&frame
->uc
.tuc_link
);
3817 __put_user(target_sigaltstack_used
.ss_sp
, &frame
->uc
.tuc_stack
.ss_sp
);
3818 __put_user(sas_ss_flags(get_sp_from_cpustate(env
)),
3819 &frame
->uc
.tuc_stack
.ss_flags
);
3820 __put_user(target_sigaltstack_used
.ss_size
, &frame
->uc
.tuc_stack
.ss_size
);
3821 save_sigregs(env
, &frame
->uc
.tuc_mcontext
);
3822 for (i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
3823 __put_user((abi_ulong
)set
->sig
[i
],
3824 (abi_ulong
*)&frame
->uc
.tuc_sigmask
.sig
[i
]);
3827 /* Set up to return from userspace. If provided, use a stub
3828 already in userspace. */
3829 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
3830 env
->regs
[14] = (unsigned long) ka
->sa_restorer
| PSW_ADDR_AMODE
;
3832 env
->regs
[14] = (unsigned long) frame
->retcode
| PSW_ADDR_AMODE
;
3833 if (__put_user(S390_SYSCALL_OPCODE
| TARGET_NR_rt_sigreturn
,
3834 (uint16_t *)(frame
->retcode
))) {
3839 /* Set up backchain. */
3840 if (__put_user(env
->regs
[15], (abi_ulong
*) frame
)) {
3844 /* Set up registers for signal handler */
3845 env
->regs
[15] = frame_addr
;
3846 env
->psw
.addr
= (target_ulong
) ka
->_sa_handler
| PSW_ADDR_AMODE
;
3848 env
->regs
[2] = sig
; //map_signal(sig);
3849 env
->regs
[3] = frame_addr
+ offsetof(typeof(*frame
), info
);
3850 env
->regs
[4] = frame_addr
+ offsetof(typeof(*frame
), uc
);
3854 qemu_log("%s: give_sigsegv\n", __FUNCTION__
);
3855 unlock_user_struct(frame
, frame_addr
, 1);
3856 force_sig(TARGET_SIGSEGV
);
3860 restore_sigregs(CPUState
*env
, target_sigregs
*sc
)
3865 for (i
= 0; i
< 16; i
++) {
3866 err
|= __get_user(env
->regs
[i
], &sc
->regs
.gprs
[i
]);
3869 err
|= __get_user(env
->psw
.mask
, &sc
->regs
.psw
.mask
);
3870 qemu_log("%s: sc->regs.psw.addr 0x%llx env->psw.addr 0x%llx\n",
3871 __FUNCTION__
, (unsigned long long)sc
->regs
.psw
.addr
,
3872 (unsigned long long)env
->psw
.addr
);
3873 err
|= __get_user(env
->psw
.addr
, &sc
->regs
.psw
.addr
);
3874 /* FIXME: 31-bit -> | PSW_ADDR_AMODE */
3876 for (i
= 0; i
< 16; i
++) {
3877 err
|= __get_user(env
->aregs
[i
], &sc
->regs
.acrs
[i
]);
3879 for (i
= 0; i
< 16; i
++) {
3880 err
|= __get_user(env
->fregs
[i
].ll
, &sc
->fpregs
.fprs
[i
]);
3886 long do_sigreturn(CPUState
*env
)
3889 abi_ulong frame_addr
= env
->regs
[15];
3890 qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__
,
3891 (unsigned long long)frame_addr
);
3892 target_sigset_t target_set
;
3895 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1)) {
3898 if (__get_user(target_set
.sig
[0], &frame
->sc
.oldmask
[0])) {
3902 target_to_host_sigset_internal(&set
, &target_set
);
3903 sigprocmask(SIG_SETMASK
, &set
, NULL
); /* ~_BLOCKABLE? */
3905 if (restore_sigregs(env
, &frame
->sregs
)) {
3909 unlock_user_struct(frame
, frame_addr
, 0);
3910 return env
->regs
[2];
3913 unlock_user_struct(frame
, frame_addr
, 0);
3914 force_sig(TARGET_SIGSEGV
);
3918 long do_rt_sigreturn(CPUState
*env
)
3921 abi_ulong frame_addr
= env
->regs
[15];
3922 qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__
,
3923 (unsigned long long)frame_addr
);
3926 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1)) {
3929 target_to_host_sigset(&set
, &frame
->uc
.tuc_sigmask
);
3931 sigprocmask(SIG_SETMASK
, &set
, NULL
); /* ~_BLOCKABLE? */
3933 if (restore_sigregs(env
, &frame
->uc
.tuc_mcontext
)) {
3937 if (do_sigaltstack(frame_addr
+ offsetof(rt_sigframe
, uc
.tuc_stack
), 0,
3938 get_sp_from_cpustate(env
)) == -EFAULT
) {
3941 unlock_user_struct(frame
, frame_addr
, 0);
3942 return env
->regs
[2];
3945 unlock_user_struct(frame
, frame_addr
, 0);
3946 force_sig(TARGET_SIGSEGV
);
3950 #elif defined(TARGET_PPC) && !defined(TARGET_PPC64)
3952 /* FIXME: Many of the structures are defined for both PPC and PPC64, but
3953 the signal handling is different enough that we haven't implemented
3954 support for PPC64 yet. Hence the restriction above.
3956 There are various #if'd blocks for code for TARGET_PPC64. These
3957 blocks should go away so that we can successfully run 32-bit and
3958 64-bit binaries on a QEMU configured for PPC64. */
3960 /* Size of dummy stack frame allocated when calling signal handler.
3961 See arch/powerpc/include/asm/ptrace.h. */
3962 #if defined(TARGET_PPC64)
3963 #define SIGNAL_FRAMESIZE 128
3965 #define SIGNAL_FRAMESIZE 64
3968 /* See arch/powerpc/include/asm/sigcontext.h. */
3969 struct target_sigcontext
{
3970 target_ulong _unused
[4];
3972 #if defined(TARGET_PPC64)
3975 target_ulong handler
;
3976 target_ulong oldmask
;
3977 target_ulong regs
; /* struct pt_regs __user * */
3978 /* TODO: PPC64 includes extra bits here. */
3981 /* Indices for target_mcontext.mc_gregs, below.
3982 See arch/powerpc/include/asm/ptrace.h for details. */
4018 TARGET_PT_ORIG_R3
= 34,
4023 /* Yes, there are two registers with #39. One is 64-bit only. */
4025 TARGET_PT_SOFTE
= 39,
4026 TARGET_PT_TRAP
= 40,
4028 TARGET_PT_DSISR
= 42,
4029 TARGET_PT_RESULT
= 43,
4030 TARGET_PT_REGS_COUNT
= 44
4033 /* See arch/powerpc/include/asm/ucontext.h. Only used for 32-bit PPC;
4034 on 64-bit PPC, sigcontext and mcontext are one and the same. */
4035 struct target_mcontext
{
4036 target_ulong mc_gregs
[48];
4037 /* Includes fpscr. */
4038 uint64_t mc_fregs
[33];
4039 target_ulong mc_pad
[2];
4040 /* We need to handle Altivec and SPE at the same time, which no
4041 kernel needs to do. Fortunately, the kernel defines this bit to
4042 be Altivec-register-large all the time, rather than trying to
4043 twiddle it based on the specific platform. */
4045 /* SPE vector registers. One extra for SPEFSCR. */
4047 /* Altivec vector registers. The packing of VSCR and VRSAVE
4048 varies depending on whether we're PPC64 or not: PPC64 splits
4049 them apart; PPC32 stuffs them together. */
4050 #if defined(TARGET_PPC64)
4051 #define QEMU_NVRREG 34
4053 #define QEMU_NVRREG 33
4055 ppc_avr_t altivec
[QEMU_NVRREG
];
4057 } mc_vregs
__attribute__((__aligned__(16)));
4060 struct target_ucontext
{
4061 target_ulong tuc_flags
;
4062 target_ulong tuc_link
; /* struct ucontext __user * */
4063 struct target_sigaltstack tuc_stack
;
4064 #if !defined(TARGET_PPC64)
4066 target_ulong tuc_regs
; /* struct mcontext __user *
4067 points to uc_mcontext field */
4069 target_sigset_t tuc_sigmask
;
4070 #if defined(TARGET_PPC64)
4071 target_sigset_t unused
[15]; /* Allow for uc_sigmask growth */
4072 struct target_sigcontext tuc_mcontext
;
4074 int32_t tuc_maskext
[30];
4075 int32_t tuc_pad2
[3];
4076 struct target_mcontext tuc_mcontext
;
4080 /* See arch/powerpc/kernel/signal_32.c. */
4081 struct target_sigframe
{
4082 struct target_sigcontext sctx
;
4083 struct target_mcontext mctx
;
4087 struct target_rt_sigframe
{
4088 struct target_siginfo info
;
4089 struct target_ucontext uc
;
4093 /* We use the mc_pad field for the signal return trampoline. */
4094 #define tramp mc_pad
4096 /* See arch/powerpc/kernel/signal.c. */
4097 static target_ulong
get_sigframe(struct target_sigaction
*ka
,
4101 target_ulong oldsp
, newsp
;
4103 oldsp
= env
->gpr
[1];
4105 if ((ka
->sa_flags
& TARGET_SA_ONSTACK
) &&
4106 (sas_ss_flags(oldsp
))) {
4107 oldsp
= (target_sigaltstack_used
.ss_sp
4108 + target_sigaltstack_used
.ss_size
);
4111 newsp
= (oldsp
- frame_size
) & ~0xFUL
;
4116 static int save_user_regs(CPUState
*env
, struct target_mcontext
*frame
,
4119 target_ulong msr
= env
->msr
;
4121 target_ulong ccr
= 0;
4123 /* In general, the kernel attempts to be intelligent about what it
4124 needs to save for Altivec/FP/SPE registers. We don't care that
4125 much, so we just go ahead and save everything. */
4127 /* Save general registers. */
4128 for (i
= 0; i
< ARRAY_SIZE(env
->gpr
); i
++) {
4129 if (__put_user(env
->gpr
[i
], &frame
->mc_gregs
[i
])) {
4133 if (__put_user(env
->nip
, &frame
->mc_gregs
[TARGET_PT_NIP
])
4134 || __put_user(env
->ctr
, &frame
->mc_gregs
[TARGET_PT_CTR
])
4135 || __put_user(env
->lr
, &frame
->mc_gregs
[TARGET_PT_LNK
])
4136 || __put_user(env
->xer
, &frame
->mc_gregs
[TARGET_PT_XER
]))
4139 for (i
= 0; i
< ARRAY_SIZE(env
->crf
); i
++) {
4140 ccr
|= env
->crf
[i
] << (32 - ((i
+ 1) * 4));
4142 if (__put_user(ccr
, &frame
->mc_gregs
[TARGET_PT_CCR
]))
4145 /* Save Altivec registers if necessary. */
4146 if (env
->insns_flags
& PPC_ALTIVEC
) {
4147 for (i
= 0; i
< ARRAY_SIZE(env
->avr
); i
++) {
4148 ppc_avr_t
*avr
= &env
->avr
[i
];
4149 ppc_avr_t
*vreg
= &frame
->mc_vregs
.altivec
[i
];
4151 if (__put_user(avr
->u64
[0], &vreg
->u64
[0]) ||
4152 __put_user(avr
->u64
[1], &vreg
->u64
[1])) {
4156 /* Set MSR_VR in the saved MSR value to indicate that
4157 frame->mc_vregs contains valid data. */
4159 if (__put_user((uint32_t)env
->spr
[SPR_VRSAVE
],
4160 &frame
->mc_vregs
.altivec
[32].u32
[3]))
4164 /* Save floating point registers. */
4165 if (env
->insns_flags
& PPC_FLOAT
) {
4166 for (i
= 0; i
< ARRAY_SIZE(env
->fpr
); i
++) {
4167 if (__put_user(env
->fpr
[i
], &frame
->mc_fregs
[i
])) {
4171 if (__put_user((uint64_t) env
->fpscr
, &frame
->mc_fregs
[32]))
4175 /* Save SPE registers. The kernel only saves the high half. */
4176 if (env
->insns_flags
& PPC_SPE
) {
4177 #if defined(TARGET_PPC64)
4178 for (i
= 0; i
< ARRAY_SIZE(env
->gpr
); i
++) {
4179 if (__put_user(env
->gpr
[i
] >> 32, &frame
->mc_vregs
.spe
[i
])) {
4184 for (i
= 0; i
< ARRAY_SIZE(env
->gprh
); i
++) {
4185 if (__put_user(env
->gprh
[i
], &frame
->mc_vregs
.spe
[i
])) {
4190 /* Set MSR_SPE in the saved MSR value to indicate that
4191 frame->mc_vregs contains valid data. */
4193 if (__put_user(env
->spe_fscr
, &frame
->mc_vregs
.spe
[32]))
4198 if (__put_user(msr
, &frame
->mc_gregs
[TARGET_PT_MSR
]))
4201 /* Set up the sigreturn trampoline: li r0,sigret; sc. */
4203 if (__put_user(0x38000000UL
| sigret
, &frame
->tramp
[0]) ||
4204 __put_user(0x44000002UL
, &frame
->tramp
[1])) {
4212 static int restore_user_regs(CPUState
*env
,
4213 struct target_mcontext
*frame
, int sig
)
4215 target_ulong save_r2
= 0;
4222 save_r2
= env
->gpr
[2];
4225 /* Restore general registers. */
4226 for (i
= 0; i
< ARRAY_SIZE(env
->gpr
); i
++) {
4227 if (__get_user(env
->gpr
[i
], &frame
->mc_gregs
[i
])) {
4231 if (__get_user(env
->nip
, &frame
->mc_gregs
[TARGET_PT_NIP
])
4232 || __get_user(env
->ctr
, &frame
->mc_gregs
[TARGET_PT_CTR
])
4233 || __get_user(env
->lr
, &frame
->mc_gregs
[TARGET_PT_LNK
])
4234 || __get_user(env
->xer
, &frame
->mc_gregs
[TARGET_PT_XER
]))
4236 if (__get_user(ccr
, &frame
->mc_gregs
[TARGET_PT_CCR
]))
4239 for (i
= 0; i
< ARRAY_SIZE(env
->crf
); i
++) {
4240 env
->crf
[i
] = (ccr
>> (32 - ((i
+ 1) * 4))) & 0xf;
4244 env
->gpr
[2] = save_r2
;
4247 if (__get_user(msr
, &frame
->mc_gregs
[TARGET_PT_MSR
]))
4250 /* If doing signal return, restore the previous little-endian mode. */
4252 env
->msr
= (env
->msr
& ~MSR_LE
) | (msr
& MSR_LE
);
4254 /* Restore Altivec registers if necessary. */
4255 if (env
->insns_flags
& PPC_ALTIVEC
) {
4256 for (i
= 0; i
< ARRAY_SIZE(env
->avr
); i
++) {
4257 ppc_avr_t
*avr
= &env
->avr
[i
];
4258 ppc_avr_t
*vreg
= &frame
->mc_vregs
.altivec
[i
];
4260 if (__get_user(avr
->u64
[0], &vreg
->u64
[0]) ||
4261 __get_user(avr
->u64
[1], &vreg
->u64
[1])) {
4265 /* Set MSR_VEC in the saved MSR value to indicate that
4266 frame->mc_vregs contains valid data. */
4267 if (__get_user(env
->spr
[SPR_VRSAVE
],
4268 (target_ulong
*)(&frame
->mc_vregs
.altivec
[32].u32
[3])))
4272 /* Restore floating point registers. */
4273 if (env
->insns_flags
& PPC_FLOAT
) {
4275 for (i
= 0; i
< ARRAY_SIZE(env
->fpr
); i
++) {
4276 if (__get_user(env
->fpr
[i
], &frame
->mc_fregs
[i
])) {
4280 if (__get_user(fpscr
, &frame
->mc_fregs
[32]))
4282 env
->fpscr
= (uint32_t) fpscr
;
4285 /* Save SPE registers. The kernel only saves the high half. */
4286 if (env
->insns_flags
& PPC_SPE
) {
4287 #if defined(TARGET_PPC64)
4288 for (i
= 0; i
< ARRAY_SIZE(env
->gpr
); i
++) {
4291 if (__get_user(hi
, &frame
->mc_vregs
.spe
[i
])) {
4294 env
->gpr
[i
] = ((uint64_t)hi
<< 32) | ((uint32_t) env
->gpr
[i
]);
4297 for (i
= 0; i
< ARRAY_SIZE(env
->gprh
); i
++) {
4298 if (__get_user(env
->gprh
[i
], &frame
->mc_vregs
.spe
[i
])) {
4303 if (__get_user(env
->spe_fscr
, &frame
->mc_vregs
.spe
[32]))
4310 static void setup_frame(int sig
, struct target_sigaction
*ka
,
4311 target_sigset_t
*set
, CPUState
*env
)
4313 struct target_sigframe
*frame
;
4314 struct target_sigcontext
*sc
;
4315 target_ulong frame_addr
, newsp
;
4319 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
4320 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 1))
4324 signal
= current_exec_domain_sig(sig
);
4326 err
|= __put_user(h2g(ka
->_sa_handler
), &sc
->handler
);
4327 err
|= __put_user(set
->sig
[0], &sc
->oldmask
);
4328 #if defined(TARGET_PPC64)
4329 err
|= __put_user(set
->sig
[0] >> 32, &sc
->_unused
[3]);
4331 err
|= __put_user(set
->sig
[1], &sc
->_unused
[3]);
4333 err
|= __put_user(h2g(&frame
->mctx
), &sc
->regs
);
4334 err
|= __put_user(sig
, &sc
->signal
);
4336 /* Save user regs. */
4337 err
|= save_user_regs(env
, &frame
->mctx
, TARGET_NR_sigreturn
);
4339 /* The kernel checks for the presence of a VDSO here. We don't
4340 emulate a vdso, so use a sigreturn system call. */
4341 env
->lr
= (target_ulong
) h2g(frame
->mctx
.tramp
);
4343 /* Turn off all fp exceptions. */
4346 /* Create a stack frame for the caller of the handler. */
4347 newsp
= frame_addr
- SIGNAL_FRAMESIZE
;
4348 err
|= __put_user(env
->gpr
[1], (target_ulong
*)(uintptr_t) newsp
);
4353 /* Set up registers for signal handler. */
4354 env
->gpr
[1] = newsp
;
4355 env
->gpr
[3] = signal
;
4356 env
->gpr
[4] = (target_ulong
) h2g(sc
);
4357 env
->nip
= (target_ulong
) ka
->_sa_handler
;
4358 /* Signal handlers are entered in big-endian mode. */
4359 env
->msr
&= ~MSR_LE
;
4361 unlock_user_struct(frame
, frame_addr
, 1);
4365 unlock_user_struct(frame
, frame_addr
, 1);
4367 fprintf (logfile
, "segfaulting from setup_frame\n");
4368 force_sig(TARGET_SIGSEGV
);
4371 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
4372 target_siginfo_t
*info
,
4373 target_sigset_t
*set
, CPUState
*env
)
4375 struct target_rt_sigframe
*rt_sf
;
4376 struct target_mcontext
*frame
;
4377 target_ulong rt_sf_addr
, newsp
= 0;
4381 rt_sf_addr
= get_sigframe(ka
, env
, sizeof(*rt_sf
));
4382 if (!lock_user_struct(VERIFY_WRITE
, rt_sf
, rt_sf_addr
, 1))
4385 signal
= current_exec_domain_sig(sig
);
4387 err
|= copy_siginfo_to_user(&rt_sf
->info
, info
);
4389 err
|= __put_user(0, &rt_sf
->uc
.tuc_flags
);
4390 err
|= __put_user(0, &rt_sf
->uc
.tuc_link
);
4391 err
|= __put_user((target_ulong
)target_sigaltstack_used
.ss_sp
,
4392 &rt_sf
->uc
.tuc_stack
.ss_sp
);
4393 err
|= __put_user(sas_ss_flags(env
->gpr
[1]),
4394 &rt_sf
->uc
.tuc_stack
.ss_flags
);
4395 err
|= __put_user(target_sigaltstack_used
.ss_size
,
4396 &rt_sf
->uc
.tuc_stack
.ss_size
);
4397 err
|= __put_user(h2g (&rt_sf
->uc
.tuc_mcontext
),
4398 &rt_sf
->uc
.tuc_regs
);
4399 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
4400 err
|= __put_user(set
->sig
[i
], &rt_sf
->uc
.tuc_sigmask
.sig
[i
]);
4403 frame
= &rt_sf
->uc
.tuc_mcontext
;
4404 err
|= save_user_regs(env
, frame
, TARGET_NR_rt_sigreturn
);
4406 /* The kernel checks for the presence of a VDSO here. We don't
4407 emulate a vdso, so use a sigreturn system call. */
4408 env
->lr
= (target_ulong
) h2g(frame
->tramp
);
4410 /* Turn off all fp exceptions. */
4413 /* Create a stack frame for the caller of the handler. */
4414 newsp
= rt_sf_addr
- (SIGNAL_FRAMESIZE
+ 16);
4415 err
|= __put_user(env
->gpr
[1], (target_ulong
*)(uintptr_t) newsp
);
4420 /* Set up registers for signal handler. */
4421 env
->gpr
[1] = newsp
;
4422 env
->gpr
[3] = (target_ulong
) signal
;
4423 env
->gpr
[4] = (target_ulong
) h2g(&rt_sf
->info
);
4424 env
->gpr
[5] = (target_ulong
) h2g(&rt_sf
->uc
);
4425 env
->gpr
[6] = (target_ulong
) h2g(rt_sf
);
4426 env
->nip
= (target_ulong
) ka
->_sa_handler
;
4427 /* Signal handlers are entered in big-endian mode. */
4428 env
->msr
&= ~MSR_LE
;
4430 unlock_user_struct(rt_sf
, rt_sf_addr
, 1);
4434 unlock_user_struct(rt_sf
, rt_sf_addr
, 1);
4436 fprintf (logfile
, "segfaulting from setup_rt_frame\n");
4437 force_sig(TARGET_SIGSEGV
);
4441 long do_sigreturn(CPUState
*env
)
4443 struct target_sigcontext
*sc
= NULL
;
4444 struct target_mcontext
*sr
= NULL
;
4445 target_ulong sr_addr
, sc_addr
;
4447 target_sigset_t set
;
4449 sc_addr
= env
->gpr
[1] + SIGNAL_FRAMESIZE
;
4450 if (!lock_user_struct(VERIFY_READ
, sc
, sc_addr
, 1))
4453 #if defined(TARGET_PPC64)
4454 set
.sig
[0] = sc
->oldmask
+ ((long)(sc
->_unused
[3]) << 32);
4456 if(__get_user(set
.sig
[0], &sc
->oldmask
) ||
4457 __get_user(set
.sig
[1], &sc
->_unused
[3]))
4460 target_to_host_sigset_internal(&blocked
, &set
);
4461 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
4463 if (__get_user(sr_addr
, &sc
->regs
))
4465 if (!lock_user_struct(VERIFY_READ
, sr
, sr_addr
, 1))
4467 if (restore_user_regs(env
, sr
, 1))
4470 unlock_user_struct(sr
, sr_addr
, 1);
4471 unlock_user_struct(sc
, sc_addr
, 1);
4472 return -TARGET_QEMU_ESIGRETURN
;
4475 unlock_user_struct(sr
, sr_addr
, 1);
4476 unlock_user_struct(sc
, sc_addr
, 1);
4478 fprintf (logfile
, "segfaulting from do_sigreturn\n");
4479 force_sig(TARGET_SIGSEGV
);
4483 /* See arch/powerpc/kernel/signal_32.c. */
4484 static int do_setcontext(struct target_ucontext
*ucp
, CPUState
*env
, int sig
)
4486 struct target_mcontext
*mcp
;
4487 target_ulong mcp_addr
;
4489 target_sigset_t set
;
4491 if (copy_from_user(&set
, h2g(ucp
) + offsetof(struct target_ucontext
, tuc_sigmask
),
4495 #if defined(TARGET_PPC64)
4496 fprintf (stderr
, "do_setcontext: not implemented\n");
4499 if (__get_user(mcp_addr
, &ucp
->tuc_regs
))
4502 if (!lock_user_struct(VERIFY_READ
, mcp
, mcp_addr
, 1))
4505 target_to_host_sigset_internal(&blocked
, &set
);
4506 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
4507 if (restore_user_regs(env
, mcp
, sig
))
4510 unlock_user_struct(mcp
, mcp_addr
, 1);
4514 unlock_user_struct(mcp
, mcp_addr
, 1);
4519 long do_rt_sigreturn(CPUState
*env
)
4521 struct target_rt_sigframe
*rt_sf
= NULL
;
4522 target_ulong rt_sf_addr
;
4524 rt_sf_addr
= env
->gpr
[1] + SIGNAL_FRAMESIZE
+ 16;
4525 if (!lock_user_struct(VERIFY_READ
, rt_sf
, rt_sf_addr
, 1))
4528 if (do_setcontext(&rt_sf
->uc
, env
, 1))
4531 do_sigaltstack(rt_sf_addr
4532 + offsetof(struct target_rt_sigframe
, uc
.tuc_stack
),
4535 unlock_user_struct(rt_sf
, rt_sf_addr
, 1);
4536 return -TARGET_QEMU_ESIGRETURN
;
4539 unlock_user_struct(rt_sf
, rt_sf_addr
, 1);
4541 fprintf (logfile
, "segfaulting from do_rt_sigreturn\n");
4542 force_sig(TARGET_SIGSEGV
);
4546 #elif defined(TARGET_M68K)
4548 struct target_sigcontext
{
4555 unsigned short sc_sr
;
4559 struct target_sigframe
4566 abi_ulong extramask
[TARGET_NSIG_WORDS
-1];
4567 struct target_sigcontext sc
;
4570 typedef int target_greg_t
;
4571 #define TARGET_NGREG 18
4572 typedef target_greg_t target_gregset_t
[TARGET_NGREG
];
4574 typedef struct target_fpregset
{
4577 } target_fpregset_t
;
4579 struct target_mcontext
{
4581 target_gregset_t gregs
;
4582 target_fpregset_t fpregs
;
4585 #define TARGET_MCONTEXT_VERSION 2
4587 struct target_ucontext
{
4588 abi_ulong tuc_flags
;
4590 target_stack_t tuc_stack
;
4591 struct target_mcontext tuc_mcontext
;
4592 abi_long tuc_filler
[80];
4593 target_sigset_t tuc_sigmask
;
4596 struct target_rt_sigframe
4603 struct target_siginfo info
;
4604 struct target_ucontext uc
;
4608 setup_sigcontext(struct target_sigcontext
*sc
, CPUState
*env
, abi_ulong mask
)
4612 err
|= __put_user(mask
, &sc
->sc_mask
);
4613 err
|= __put_user(env
->aregs
[7], &sc
->sc_usp
);
4614 err
|= __put_user(env
->dregs
[0], &sc
->sc_d0
);
4615 err
|= __put_user(env
->dregs
[1], &sc
->sc_d1
);
4616 err
|= __put_user(env
->aregs
[0], &sc
->sc_a0
);
4617 err
|= __put_user(env
->aregs
[1], &sc
->sc_a1
);
4618 err
|= __put_user(env
->sr
, &sc
->sc_sr
);
4619 err
|= __put_user(env
->pc
, &sc
->sc_pc
);
4625 restore_sigcontext(CPUState
*env
, struct target_sigcontext
*sc
, int *pd0
)
4630 err
|= __get_user(env
->aregs
[7], &sc
->sc_usp
);
4631 err
|= __get_user(env
->dregs
[1], &sc
->sc_d1
);
4632 err
|= __get_user(env
->aregs
[0], &sc
->sc_a0
);
4633 err
|= __get_user(env
->aregs
[1], &sc
->sc_a1
);
4634 err
|= __get_user(env
->pc
, &sc
->sc_pc
);
4635 err
|= __get_user(temp
, &sc
->sc_sr
);
4636 env
->sr
= (env
->sr
& 0xff00) | (temp
& 0xff);
4638 *pd0
= tswapl(sc
->sc_d0
);
4644 * Determine which stack to use..
4646 static inline abi_ulong
4647 get_sigframe(struct target_sigaction
*ka
, CPUState
*regs
, size_t frame_size
)
4651 sp
= regs
->aregs
[7];
4653 /* This is the X/Open sanctioned signal stack switching. */
4654 if ((ka
->sa_flags
& TARGET_SA_ONSTACK
) && (sas_ss_flags (sp
) == 0)) {
4655 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
4658 return ((sp
- frame_size
) & -8UL);
4661 static void setup_frame(int sig
, struct target_sigaction
*ka
,
4662 target_sigset_t
*set
, CPUState
*env
)
4664 struct target_sigframe
*frame
;
4665 abi_ulong frame_addr
;
4666 abi_ulong retcode_addr
;
4671 frame_addr
= get_sigframe(ka
, env
, sizeof *frame
);
4672 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
4675 err
|= __put_user(sig
, &frame
->sig
);
4677 sc_addr
= frame_addr
+ offsetof(struct target_sigframe
, sc
);
4678 err
|= __put_user(sc_addr
, &frame
->psc
);
4680 err
|= setup_sigcontext(&frame
->sc
, env
, set
->sig
[0]);
4684 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
4685 if (__put_user(set
->sig
[i
], &frame
->extramask
[i
- 1]))
4689 /* Set up to return from userspace. */
4691 retcode_addr
= frame_addr
+ offsetof(struct target_sigframe
, retcode
);
4692 err
|= __put_user(retcode_addr
, &frame
->pretcode
);
4694 /* moveq #,d0; trap #0 */
4696 err
|= __put_user(0x70004e40 + (TARGET_NR_sigreturn
<< 16),
4697 (long *)(frame
->retcode
));
4702 /* Set up to return from userspace */
4704 env
->aregs
[7] = frame_addr
;
4705 env
->pc
= ka
->_sa_handler
;
4707 unlock_user_struct(frame
, frame_addr
, 1);
4711 unlock_user_struct(frame
, frame_addr
, 1);
4712 force_sig(TARGET_SIGSEGV
);
4715 static inline int target_rt_setup_ucontext(struct target_ucontext
*uc
,
4718 target_greg_t
*gregs
= uc
->tuc_mcontext
.gregs
;
4721 err
= __put_user(TARGET_MCONTEXT_VERSION
, &uc
->tuc_mcontext
.version
);
4722 err
|= __put_user(env
->dregs
[0], &gregs
[0]);
4723 err
|= __put_user(env
->dregs
[1], &gregs
[1]);
4724 err
|= __put_user(env
->dregs
[2], &gregs
[2]);
4725 err
|= __put_user(env
->dregs
[3], &gregs
[3]);
4726 err
|= __put_user(env
->dregs
[4], &gregs
[4]);
4727 err
|= __put_user(env
->dregs
[5], &gregs
[5]);
4728 err
|= __put_user(env
->dregs
[6], &gregs
[6]);
4729 err
|= __put_user(env
->dregs
[7], &gregs
[7]);
4730 err
|= __put_user(env
->aregs
[0], &gregs
[8]);
4731 err
|= __put_user(env
->aregs
[1], &gregs
[9]);
4732 err
|= __put_user(env
->aregs
[2], &gregs
[10]);
4733 err
|= __put_user(env
->aregs
[3], &gregs
[11]);
4734 err
|= __put_user(env
->aregs
[4], &gregs
[12]);
4735 err
|= __put_user(env
->aregs
[5], &gregs
[13]);
4736 err
|= __put_user(env
->aregs
[6], &gregs
[14]);
4737 err
|= __put_user(env
->aregs
[7], &gregs
[15]);
4738 err
|= __put_user(env
->pc
, &gregs
[16]);
4739 err
|= __put_user(env
->sr
, &gregs
[17]);
4744 static inline int target_rt_restore_ucontext(CPUState
*env
,
4745 struct target_ucontext
*uc
,
4750 target_greg_t
*gregs
= uc
->tuc_mcontext
.gregs
;
4752 err
= __get_user(temp
, &uc
->tuc_mcontext
.version
);
4753 if (temp
!= TARGET_MCONTEXT_VERSION
)
4756 /* restore passed registers */
4757 err
|= __get_user(env
->dregs
[0], &gregs
[0]);
4758 err
|= __get_user(env
->dregs
[1], &gregs
[1]);
4759 err
|= __get_user(env
->dregs
[2], &gregs
[2]);
4760 err
|= __get_user(env
->dregs
[3], &gregs
[3]);
4761 err
|= __get_user(env
->dregs
[4], &gregs
[4]);
4762 err
|= __get_user(env
->dregs
[5], &gregs
[5]);
4763 err
|= __get_user(env
->dregs
[6], &gregs
[6]);
4764 err
|= __get_user(env
->dregs
[7], &gregs
[7]);
4765 err
|= __get_user(env
->aregs
[0], &gregs
[8]);
4766 err
|= __get_user(env
->aregs
[1], &gregs
[9]);
4767 err
|= __get_user(env
->aregs
[2], &gregs
[10]);
4768 err
|= __get_user(env
->aregs
[3], &gregs
[11]);
4769 err
|= __get_user(env
->aregs
[4], &gregs
[12]);
4770 err
|= __get_user(env
->aregs
[5], &gregs
[13]);
4771 err
|= __get_user(env
->aregs
[6], &gregs
[14]);
4772 err
|= __get_user(env
->aregs
[7], &gregs
[15]);
4773 err
|= __get_user(env
->pc
, &gregs
[16]);
4774 err
|= __get_user(temp
, &gregs
[17]);
4775 env
->sr
= (env
->sr
& 0xff00) | (temp
& 0xff);
4777 *pd0
= env
->dregs
[0];
4784 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
4785 target_siginfo_t
*info
,
4786 target_sigset_t
*set
, CPUState
*env
)
4788 struct target_rt_sigframe
*frame
;
4789 abi_ulong frame_addr
;
4790 abi_ulong retcode_addr
;
4791 abi_ulong info_addr
;
4796 frame_addr
= get_sigframe(ka
, env
, sizeof *frame
);
4797 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
4800 err
|= __put_user(sig
, &frame
->sig
);
4802 info_addr
= frame_addr
+ offsetof(struct target_rt_sigframe
, info
);
4803 err
|= __put_user(info_addr
, &frame
->pinfo
);
4805 uc_addr
= frame_addr
+ offsetof(struct target_rt_sigframe
, uc
);
4806 err
|= __put_user(uc_addr
, &frame
->puc
);
4808 err
|= copy_siginfo_to_user(&frame
->info
, info
);
4810 /* Create the ucontext */
4812 err
|= __put_user(0, &frame
->uc
.tuc_flags
);
4813 err
|= __put_user(0, &frame
->uc
.tuc_link
);
4814 err
|= __put_user(target_sigaltstack_used
.ss_sp
,
4815 &frame
->uc
.tuc_stack
.ss_sp
);
4816 err
|= __put_user(sas_ss_flags(env
->aregs
[7]),
4817 &frame
->uc
.tuc_stack
.ss_flags
);
4818 err
|= __put_user(target_sigaltstack_used
.ss_size
,
4819 &frame
->uc
.tuc_stack
.ss_size
);
4820 err
|= target_rt_setup_ucontext(&frame
->uc
, env
);
4825 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
4826 if (__put_user(set
->sig
[i
], &frame
->uc
.tuc_sigmask
.sig
[i
]))
4830 /* Set up to return from userspace. */
4832 retcode_addr
= frame_addr
+ offsetof(struct target_sigframe
, retcode
);
4833 err
|= __put_user(retcode_addr
, &frame
->pretcode
);
4835 /* moveq #,d0; notb d0; trap #0 */
4837 err
|= __put_user(0x70004600 + ((TARGET_NR_rt_sigreturn
^ 0xff) << 16),
4838 (long *)(frame
->retcode
+ 0));
4839 err
|= __put_user(0x4e40, (short *)(frame
->retcode
+ 4));
4844 /* Set up to return from userspace */
4846 env
->aregs
[7] = frame_addr
;
4847 env
->pc
= ka
->_sa_handler
;
4849 unlock_user_struct(frame
, frame_addr
, 1);
4853 unlock_user_struct(frame
, frame_addr
, 1);
4854 force_sig(TARGET_SIGSEGV
);
4857 long do_sigreturn(CPUState
*env
)
4859 struct target_sigframe
*frame
;
4860 abi_ulong frame_addr
= env
->aregs
[7] - 4;
4861 target_sigset_t target_set
;
4865 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
4868 /* set blocked signals */
4870 if (__get_user(target_set
.sig
[0], &frame
->sc
.sc_mask
))
4873 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
4874 if (__get_user(target_set
.sig
[i
], &frame
->extramask
[i
- 1]))
4878 target_to_host_sigset_internal(&set
, &target_set
);
4879 sigprocmask(SIG_SETMASK
, &set
, NULL
);
4881 /* restore registers */
4883 if (restore_sigcontext(env
, &frame
->sc
, &d0
))
4886 unlock_user_struct(frame
, frame_addr
, 0);
4890 unlock_user_struct(frame
, frame_addr
, 0);
4891 force_sig(TARGET_SIGSEGV
);
4895 long do_rt_sigreturn(CPUState
*env
)
4897 struct target_rt_sigframe
*frame
;
4898 abi_ulong frame_addr
= env
->aregs
[7] - 4;
4899 target_sigset_t target_set
;
4903 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
4906 target_to_host_sigset_internal(&set
, &target_set
);
4907 sigprocmask(SIG_SETMASK
, &set
, NULL
);
4909 /* restore registers */
4911 if (target_rt_restore_ucontext(env
, &frame
->uc
, &d0
))
4914 if (do_sigaltstack(frame_addr
+
4915 offsetof(struct target_rt_sigframe
, uc
.tuc_stack
),
4916 0, get_sp_from_cpustate(env
)) == -EFAULT
)
4919 unlock_user_struct(frame
, frame_addr
, 0);
4923 unlock_user_struct(frame
, frame_addr
, 0);
4924 force_sig(TARGET_SIGSEGV
);
4928 #elif defined(TARGET_ALPHA)
4930 struct target_sigcontext
{
4931 abi_long sc_onstack
;
4935 abi_long sc_regs
[32];
4936 abi_long sc_ownedfp
;
4937 abi_long sc_fpregs
[32];
4939 abi_ulong sc_fp_control
;
4940 abi_ulong sc_reserved1
;
4941 abi_ulong sc_reserved2
;
4944 abi_ulong sc_traparg_a0
;
4945 abi_ulong sc_traparg_a1
;
4946 abi_ulong sc_traparg_a2
;
4947 abi_ulong sc_fp_trap_pc
;
4948 abi_ulong sc_fp_trigger_sum
;
4949 abi_ulong sc_fp_trigger_inst
;
4952 struct target_ucontext
{
4953 abi_ulong tuc_flags
;
4955 abi_ulong tuc_osf_sigmask
;
4956 target_stack_t tuc_stack
;
4957 struct target_sigcontext tuc_mcontext
;
4958 target_sigset_t tuc_sigmask
;
4961 struct target_sigframe
{
4962 struct target_sigcontext sc
;
4963 unsigned int retcode
[3];
4966 struct target_rt_sigframe
{
4967 target_siginfo_t info
;
4968 struct target_ucontext uc
;
4969 unsigned int retcode
[3];
4972 #define INSN_MOV_R30_R16 0x47fe0410
4973 #define INSN_LDI_R0 0x201f0000
4974 #define INSN_CALLSYS 0x00000083
4976 static int setup_sigcontext(struct target_sigcontext
*sc
, CPUState
*env
,
4977 abi_ulong frame_addr
, target_sigset_t
*set
)
4981 err
|= __put_user(on_sig_stack(frame_addr
), &sc
->sc_onstack
);
4982 err
|= __put_user(set
->sig
[0], &sc
->sc_mask
);
4983 err
|= __put_user(env
->pc
, &sc
->sc_pc
);
4984 err
|= __put_user(8, &sc
->sc_ps
);
4986 for (i
= 0; i
< 31; ++i
) {
4987 err
|= __put_user(env
->ir
[i
], &sc
->sc_regs
[i
]);
4989 err
|= __put_user(0, &sc
->sc_regs
[31]);
4991 for (i
= 0; i
< 31; ++i
) {
4992 err
|= __put_user(env
->fir
[i
], &sc
->sc_fpregs
[i
]);
4994 err
|= __put_user(0, &sc
->sc_fpregs
[31]);
4995 err
|= __put_user(cpu_alpha_load_fpcr(env
), &sc
->sc_fpcr
);
4997 err
|= __put_user(0, &sc
->sc_traparg_a0
); /* FIXME */
4998 err
|= __put_user(0, &sc
->sc_traparg_a1
); /* FIXME */
4999 err
|= __put_user(0, &sc
->sc_traparg_a2
); /* FIXME */
5004 static int restore_sigcontext(CPUState
*env
, struct target_sigcontext
*sc
)
5009 err
|= __get_user(env
->pc
, &sc
->sc_pc
);
5011 for (i
= 0; i
< 31; ++i
) {
5012 err
|= __get_user(env
->ir
[i
], &sc
->sc_regs
[i
]);
5014 for (i
= 0; i
< 31; ++i
) {
5015 err
|= __get_user(env
->fir
[i
], &sc
->sc_fpregs
[i
]);
5018 err
|= __get_user(fpcr
, &sc
->sc_fpcr
);
5019 cpu_alpha_store_fpcr(env
, fpcr
);
5024 static inline abi_ulong
get_sigframe(struct target_sigaction
*sa
,
5025 CPUState
*env
, unsigned long framesize
)
5027 abi_ulong sp
= env
->ir
[IR_SP
];
5029 /* This is the X/Open sanctioned signal stack switching. */
5030 if ((sa
->sa_flags
& TARGET_SA_ONSTACK
) != 0 && !sas_ss_flags(sp
)) {
5031 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
5033 return (sp
- framesize
) & -32;
5036 static void setup_frame(int sig
, struct target_sigaction
*ka
,
5037 target_sigset_t
*set
, CPUState
*env
)
5039 abi_ulong frame_addr
, r26
;
5040 struct target_sigframe
*frame
;
5043 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
5044 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0)) {
5048 err
|= setup_sigcontext(&frame
->sc
, env
, frame_addr
, set
);
5050 if (ka
->sa_restorer
) {
5051 r26
= ka
->sa_restorer
;
5053 err
|= __put_user(INSN_MOV_R30_R16
, &frame
->retcode
[0]);
5054 err
|= __put_user(INSN_LDI_R0
+ TARGET_NR_sigreturn
,
5055 &frame
->retcode
[1]);
5056 err
|= __put_user(INSN_CALLSYS
, &frame
->retcode
[2]);
5061 unlock_user_struct(frame
, frame_addr
, 1);
5065 if (sig
== TARGET_SIGSEGV
) {
5066 ka
->_sa_handler
= TARGET_SIG_DFL
;
5068 force_sig(TARGET_SIGSEGV
);
5071 env
->ir
[IR_RA
] = r26
;
5072 env
->ir
[IR_PV
] = env
->pc
= ka
->_sa_handler
;
5073 env
->ir
[IR_A0
] = sig
;
5075 env
->ir
[IR_A2
] = frame_addr
+ offsetof(struct target_sigframe
, sc
);
5076 env
->ir
[IR_SP
] = frame_addr
;
5079 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
5080 target_siginfo_t
*info
,
5081 target_sigset_t
*set
, CPUState
*env
)
5083 abi_ulong frame_addr
, r26
;
5084 struct target_rt_sigframe
*frame
;
5087 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
5088 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0)) {
5092 err
|= copy_siginfo_to_user(&frame
->info
, info
);
5094 err
|= __put_user(0, &frame
->uc
.tuc_flags
);
5095 err
|= __put_user(0, &frame
->uc
.tuc_link
);
5096 err
|= __put_user(set
->sig
[0], &frame
->uc
.tuc_osf_sigmask
);
5097 err
|= __put_user(target_sigaltstack_used
.ss_sp
,
5098 &frame
->uc
.tuc_stack
.ss_sp
);
5099 err
|= __put_user(sas_ss_flags(env
->ir
[IR_SP
]),
5100 &frame
->uc
.tuc_stack
.ss_flags
);
5101 err
|= __put_user(target_sigaltstack_used
.ss_size
,
5102 &frame
->uc
.tuc_stack
.ss_size
);
5103 err
|= setup_sigcontext(&frame
->uc
.tuc_mcontext
, env
, frame_addr
, set
);
5104 for (i
= 0; i
< TARGET_NSIG_WORDS
; ++i
) {
5105 err
|= __put_user(set
->sig
[i
], &frame
->uc
.tuc_sigmask
.sig
[i
]);
5108 if (ka
->sa_restorer
) {
5109 r26
= ka
->sa_restorer
;
5111 err
|= __put_user(INSN_MOV_R30_R16
, &frame
->retcode
[0]);
5112 err
|= __put_user(INSN_LDI_R0
+ TARGET_NR_rt_sigreturn
,
5113 &frame
->retcode
[1]);
5114 err
|= __put_user(INSN_CALLSYS
, &frame
->retcode
[2]);
5121 if (sig
== TARGET_SIGSEGV
) {
5122 ka
->_sa_handler
= TARGET_SIG_DFL
;
5124 force_sig(TARGET_SIGSEGV
);
5127 env
->ir
[IR_RA
] = r26
;
5128 env
->ir
[IR_PV
] = env
->pc
= ka
->_sa_handler
;
5129 env
->ir
[IR_A0
] = sig
;
5130 env
->ir
[IR_A1
] = frame_addr
+ offsetof(struct target_rt_sigframe
, info
);
5131 env
->ir
[IR_A2
] = frame_addr
+ offsetof(struct target_rt_sigframe
, uc
);
5132 env
->ir
[IR_SP
] = frame_addr
;
5135 long do_sigreturn(CPUState
*env
)
5137 struct target_sigcontext
*sc
;
5138 abi_ulong sc_addr
= env
->ir
[IR_A0
];
5139 target_sigset_t target_set
;
5142 if (!lock_user_struct(VERIFY_READ
, sc
, sc_addr
, 1)) {
5146 target_sigemptyset(&target_set
);
5147 if (__get_user(target_set
.sig
[0], &sc
->sc_mask
)) {
5151 target_to_host_sigset_internal(&set
, &target_set
);
5152 sigprocmask(SIG_SETMASK
, &set
, NULL
);
5154 if (restore_sigcontext(env
, sc
)) {
5157 unlock_user_struct(sc
, sc_addr
, 0);
5158 return env
->ir
[IR_V0
];
5161 unlock_user_struct(sc
, sc_addr
, 0);
5162 force_sig(TARGET_SIGSEGV
);
5165 long do_rt_sigreturn(CPUState
*env
)
5167 abi_ulong frame_addr
= env
->ir
[IR_A0
];
5168 struct target_rt_sigframe
*frame
;
5171 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1)) {
5174 target_to_host_sigset(&set
, &frame
->uc
.tuc_sigmask
);
5175 sigprocmask(SIG_SETMASK
, &set
, NULL
);
5177 if (restore_sigcontext(env
, &frame
->uc
.tuc_mcontext
)) {
5180 if (do_sigaltstack(frame_addr
+ offsetof(struct target_rt_sigframe
,
5182 0, env
->ir
[IR_SP
]) == -EFAULT
) {
5186 unlock_user_struct(frame
, frame_addr
, 0);
5187 return env
->ir
[IR_V0
];
5191 unlock_user_struct(frame
, frame_addr
, 0);
5192 force_sig(TARGET_SIGSEGV
);
5197 static void setup_frame(int sig
, struct target_sigaction
*ka
,
5198 target_sigset_t
*set
, CPUState
*env
)
5200 fprintf(stderr
, "setup_frame: not implemented\n");
5203 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
5204 target_siginfo_t
*info
,
5205 target_sigset_t
*set
, CPUState
*env
)
5207 fprintf(stderr
, "setup_rt_frame: not implemented\n");
5210 long do_sigreturn(CPUState
*env
)
5212 fprintf(stderr
, "do_sigreturn: not implemented\n");
5213 return -TARGET_ENOSYS
;
5216 long do_rt_sigreturn(CPUState
*env
)
5218 fprintf(stderr
, "do_rt_sigreturn: not implemented\n");
5219 return -TARGET_ENOSYS
;
5224 void process_pending_signals(CPUState
*cpu_env
)
5228 sigset_t set
, old_set
;
5229 target_sigset_t target_old_set
;
5230 struct emulated_sigtable
*k
;
5231 struct target_sigaction
*sa
;
5233 TaskState
*ts
= cpu_env
->opaque
;
5235 if (!ts
->signal_pending
)
5238 /* FIXME: This is not threadsafe. */
5240 for(sig
= 1; sig
<= TARGET_NSIG
; sig
++) {
5245 /* if no signal is pending, just return */
5246 ts
->signal_pending
= 0;
5251 fprintf(stderr
, "qemu: process signal %d\n", sig
);
5253 /* dequeue signal */
5259 sig
= gdb_handlesig (cpu_env
, sig
);
5262 handler
= TARGET_SIG_IGN
;
5264 sa
= &sigact_table
[sig
- 1];
5265 handler
= sa
->_sa_handler
;
5268 if (handler
== TARGET_SIG_DFL
) {
5269 /* default handler : ignore some signal. The other are job control or fatal */
5270 if (sig
== TARGET_SIGTSTP
|| sig
== TARGET_SIGTTIN
|| sig
== TARGET_SIGTTOU
) {
5271 kill(getpid(),SIGSTOP
);
5272 } else if (sig
!= TARGET_SIGCHLD
&&
5273 sig
!= TARGET_SIGURG
&&
5274 sig
!= TARGET_SIGWINCH
&&
5275 sig
!= TARGET_SIGCONT
) {
5278 } else if (handler
== TARGET_SIG_IGN
) {
5280 } else if (handler
== TARGET_SIG_ERR
) {
5283 /* compute the blocked signals during the handler execution */
5284 target_to_host_sigset(&set
, &sa
->sa_mask
);
5285 /* SA_NODEFER indicates that the current signal should not be
5286 blocked during the handler */
5287 if (!(sa
->sa_flags
& TARGET_SA_NODEFER
))
5288 sigaddset(&set
, target_to_host_signal(sig
));
5290 /* block signals in the handler using Linux */
5291 sigprocmask(SIG_BLOCK
, &set
, &old_set
);
5292 /* save the previous blocked signal state to restore it at the
5293 end of the signal execution (see do_sigreturn) */
5294 host_to_target_sigset_internal(&target_old_set
, &old_set
);
5296 /* if the CPU is in VM86 mode, we restore the 32 bit values */
5297 #if defined(TARGET_I386) && !defined(TARGET_X86_64)
5299 CPUX86State
*env
= cpu_env
;
5300 if (env
->eflags
& VM_MASK
)
5301 save_v86_state(env
);
5304 /* prepare the stack frame of the virtual CPU */
5305 if (sa
->sa_flags
& TARGET_SA_SIGINFO
)
5306 setup_rt_frame(sig
, sa
, &q
->info
, &target_old_set
, cpu_env
);
5308 setup_frame(sig
, sa
, &target_old_set
, cpu_env
);
5309 if (sa
->sa_flags
& TARGET_SA_RESETHAND
)
5310 sa
->_sa_handler
= TARGET_SIG_DFL
;
5313 free_sigqueue(cpu_env
, q
);