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 no one 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
)
105 if (sig
< 0 || sig
>= _NSIG
)
107 return host_to_target_signal_table
[sig
];
110 int target_to_host_signal(int sig
)
112 if (sig
< 0 || sig
>= _NSIG
)
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
] = tswapal(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
] = tswapal(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
)
205 int sig
= host_to_target_signal(info
->si_signo
);
206 tinfo
->si_signo
= sig
;
208 tinfo
->si_code
= info
->si_code
;
210 if (sig
== TARGET_SIGILL
|| sig
== TARGET_SIGFPE
|| sig
== TARGET_SIGSEGV
211 || sig
== TARGET_SIGBUS
|| sig
== TARGET_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
== TARGET_SIGIO
) {
216 tinfo
->_sifields
._sigpoll
._band
= info
->si_band
;
217 tinfo
->_sifields
._sigpoll
._fd
= info
->si_fd
;
218 } else if (sig
== TARGET_SIGCHLD
) {
219 tinfo
->_sifields
._sigchld
._pid
= info
->si_pid
;
220 tinfo
->_sifields
._sigchld
._uid
= info
->si_uid
;
221 tinfo
->_sifields
._sigchld
._status
222 = host_to_target_waitstatus(info
->si_status
);
223 tinfo
->_sifields
._sigchld
._utime
= info
->si_utime
;
224 tinfo
->_sifields
._sigchld
._stime
= info
->si_stime
;
225 } else if (sig
>= TARGET_SIGRTMIN
) {
226 tinfo
->_sifields
._rt
._pid
= info
->si_pid
;
227 tinfo
->_sifields
._rt
._uid
= info
->si_uid
;
228 /* XXX: potential problem if 64 bit */
229 tinfo
->_sifields
._rt
._sigval
.sival_ptr
230 = (abi_ulong
)(unsigned long)info
->si_value
.sival_ptr
;
234 static void tswap_siginfo(target_siginfo_t
*tinfo
,
235 const target_siginfo_t
*info
)
237 int sig
= info
->si_signo
;
238 tinfo
->si_signo
= tswap32(sig
);
239 tinfo
->si_errno
= tswap32(info
->si_errno
);
240 tinfo
->si_code
= tswap32(info
->si_code
);
242 if (sig
== TARGET_SIGILL
|| sig
== TARGET_SIGFPE
|| sig
== TARGET_SIGSEGV
243 || sig
== TARGET_SIGBUS
|| sig
== TARGET_SIGTRAP
) {
244 tinfo
->_sifields
._sigfault
._addr
245 = tswapal(info
->_sifields
._sigfault
._addr
);
246 } else if (sig
== TARGET_SIGIO
) {
247 tinfo
->_sifields
._sigpoll
._band
248 = tswap32(info
->_sifields
._sigpoll
._band
);
249 tinfo
->_sifields
._sigpoll
._fd
= tswap32(info
->_sifields
._sigpoll
._fd
);
250 } else if (sig
== TARGET_SIGCHLD
) {
251 tinfo
->_sifields
._sigchld
._pid
252 = tswap32(info
->_sifields
._sigchld
._pid
);
253 tinfo
->_sifields
._sigchld
._uid
254 = tswap32(info
->_sifields
._sigchld
._uid
);
255 tinfo
->_sifields
._sigchld
._status
256 = tswap32(info
->_sifields
._sigchld
._status
);
257 tinfo
->_sifields
._sigchld
._utime
258 = tswapal(info
->_sifields
._sigchld
._utime
);
259 tinfo
->_sifields
._sigchld
._stime
260 = tswapal(info
->_sifields
._sigchld
._stime
);
261 } else if (sig
>= TARGET_SIGRTMIN
) {
262 tinfo
->_sifields
._rt
._pid
= tswap32(info
->_sifields
._rt
._pid
);
263 tinfo
->_sifields
._rt
._uid
= tswap32(info
->_sifields
._rt
._uid
);
264 tinfo
->_sifields
._rt
._sigval
.sival_ptr
265 = tswapal(info
->_sifields
._rt
._sigval
.sival_ptr
);
270 void host_to_target_siginfo(target_siginfo_t
*tinfo
, const siginfo_t
*info
)
272 host_to_target_siginfo_noswap(tinfo
, info
);
273 tswap_siginfo(tinfo
, tinfo
);
276 /* XXX: we support only POSIX RT signals are used. */
277 /* XXX: find a solution for 64 bit (additional malloced data is needed) */
278 void target_to_host_siginfo(siginfo_t
*info
, const target_siginfo_t
*tinfo
)
280 info
->si_signo
= tswap32(tinfo
->si_signo
);
281 info
->si_errno
= tswap32(tinfo
->si_errno
);
282 info
->si_code
= tswap32(tinfo
->si_code
);
283 info
->si_pid
= tswap32(tinfo
->_sifields
._rt
._pid
);
284 info
->si_uid
= tswap32(tinfo
->_sifields
._rt
._uid
);
285 info
->si_value
.sival_ptr
=
286 (void *)(long)tswapal(tinfo
->_sifields
._rt
._sigval
.sival_ptr
);
289 static int fatal_signal (int sig
)
294 case TARGET_SIGWINCH
:
295 /* Ignored by default. */
302 /* Job control signals. */
309 /* returns 1 if given signal should dump core if not handled */
310 static int core_dump_signal(int sig
)
326 void signal_init(void)
328 struct sigaction act
;
329 struct sigaction oact
;
333 /* generate signal conversion tables */
334 for(i
= 1; i
< _NSIG
; i
++) {
335 if (host_to_target_signal_table
[i
] == 0)
336 host_to_target_signal_table
[i
] = i
;
338 for(i
= 1; i
< _NSIG
; i
++) {
339 j
= host_to_target_signal_table
[i
];
340 target_to_host_signal_table
[j
] = i
;
343 /* set all host signal handlers. ALL signals are blocked during
344 the handlers to serialize them. */
345 memset(sigact_table
, 0, sizeof(sigact_table
));
347 sigfillset(&act
.sa_mask
);
348 act
.sa_flags
= SA_SIGINFO
;
349 act
.sa_sigaction
= host_signal_handler
;
350 for(i
= 1; i
<= TARGET_NSIG
; i
++) {
351 host_sig
= target_to_host_signal(i
);
352 sigaction(host_sig
, NULL
, &oact
);
353 if (oact
.sa_sigaction
== (void *)SIG_IGN
) {
354 sigact_table
[i
- 1]._sa_handler
= TARGET_SIG_IGN
;
355 } else if (oact
.sa_sigaction
== (void *)SIG_DFL
) {
356 sigact_table
[i
- 1]._sa_handler
= TARGET_SIG_DFL
;
358 /* If there's already a handler installed then something has
359 gone horribly wrong, so don't even try to handle that case. */
360 /* Install some handlers for our own use. We need at least
361 SIGSEGV and SIGBUS, to detect exceptions. We can not just
362 trap all signals because it affects syscall interrupt
363 behavior. But do trap all default-fatal signals. */
364 if (fatal_signal (i
))
365 sigaction(host_sig
, &act
, NULL
);
369 /* signal queue handling */
371 static inline struct sigqueue
*alloc_sigqueue(CPUArchState
*env
)
373 TaskState
*ts
= env
->opaque
;
374 struct sigqueue
*q
= ts
->first_free
;
377 ts
->first_free
= q
->next
;
381 static inline void free_sigqueue(CPUArchState
*env
, struct sigqueue
*q
)
383 TaskState
*ts
= env
->opaque
;
384 q
->next
= ts
->first_free
;
388 /* abort execution with signal */
389 static void QEMU_NORETURN
force_sig(int target_sig
)
391 CPUArchState
*env
= thread_cpu
->env_ptr
;
392 TaskState
*ts
= (TaskState
*)env
->opaque
;
393 int host_sig
, core_dumped
= 0;
394 struct sigaction act
;
395 host_sig
= target_to_host_signal(target_sig
);
396 gdb_signalled(env
, target_sig
);
398 /* dump core if supported by target binary format */
399 if (core_dump_signal(target_sig
) && (ts
->bprm
->core_dump
!= NULL
)) {
402 ((*ts
->bprm
->core_dump
)(target_sig
, env
) == 0);
405 /* we already dumped the core of target process, we don't want
406 * a coredump of qemu itself */
407 struct rlimit nodump
;
408 getrlimit(RLIMIT_CORE
, &nodump
);
410 setrlimit(RLIMIT_CORE
, &nodump
);
411 (void) fprintf(stderr
, "qemu: uncaught target signal %d (%s) - %s\n",
412 target_sig
, strsignal(host_sig
), "core dumped" );
415 /* The proper exit code for dying from an uncaught signal is
416 * -<signal>. The kernel doesn't allow exit() or _exit() to pass
417 * a negative value. To get the proper exit code we need to
418 * actually die from an uncaught signal. Here the default signal
419 * handler is installed, we send ourself a signal and we wait for
421 sigfillset(&act
.sa_mask
);
422 act
.sa_handler
= SIG_DFL
;
423 sigaction(host_sig
, &act
, NULL
);
425 /* For some reason raise(host_sig) doesn't send the signal when
426 * statically linked on x86-64. */
427 kill(getpid(), host_sig
);
429 /* Make sure the signal isn't masked (just reuse the mask inside
431 sigdelset(&act
.sa_mask
, host_sig
);
432 sigsuspend(&act
.sa_mask
);
438 /* queue a signal so that it will be send to the virtual CPU as soon
440 int queue_signal(CPUArchState
*env
, int sig
, target_siginfo_t
*info
)
442 TaskState
*ts
= env
->opaque
;
443 struct emulated_sigtable
*k
;
444 struct sigqueue
*q
, **pq
;
448 #if defined(DEBUG_SIGNAL)
449 fprintf(stderr
, "queue_signal: sig=%d\n",
452 k
= &ts
->sigtab
[sig
- 1];
453 queue
= gdb_queuesig ();
454 handler
= sigact_table
[sig
- 1]._sa_handler
;
455 if (!queue
&& handler
== TARGET_SIG_DFL
) {
456 if (sig
== TARGET_SIGTSTP
|| sig
== TARGET_SIGTTIN
|| sig
== TARGET_SIGTTOU
) {
457 kill(getpid(),SIGSTOP
);
460 /* default handler : ignore some signal. The other are fatal */
461 if (sig
!= TARGET_SIGCHLD
&&
462 sig
!= TARGET_SIGURG
&&
463 sig
!= TARGET_SIGWINCH
&&
464 sig
!= TARGET_SIGCONT
) {
467 return 0; /* indicate ignored */
469 } else if (!queue
&& handler
== TARGET_SIG_IGN
) {
472 } else if (!queue
&& handler
== TARGET_SIG_ERR
) {
476 if (sig
< TARGET_SIGRTMIN
) {
477 /* if non real time signal, we queue exactly one signal */
487 q
= alloc_sigqueue(env
);
498 /* signal that a new signal is pending */
499 ts
->signal_pending
= 1;
500 return 1; /* indicates that the signal was queued */
504 static void host_signal_handler(int host_signum
, siginfo_t
*info
,
507 CPUArchState
*env
= thread_cpu
->env_ptr
;
509 target_siginfo_t tinfo
;
511 /* the CPU emulator uses some host signals to detect exceptions,
512 we forward to it some signals */
513 if ((host_signum
== SIGSEGV
|| host_signum
== SIGBUS
)
514 && info
->si_code
> 0) {
515 if (cpu_signal_handler(host_signum
, info
, puc
))
519 /* get target signal number */
520 sig
= host_to_target_signal(host_signum
);
521 if (sig
< 1 || sig
> TARGET_NSIG
)
523 #if defined(DEBUG_SIGNAL)
524 fprintf(stderr
, "qemu: got signal %d\n", sig
);
526 host_to_target_siginfo_noswap(&tinfo
, info
);
527 if (queue_signal(env
, sig
, &tinfo
) == 1) {
528 /* interrupt the virtual CPU as soon as possible */
529 cpu_exit(thread_cpu
);
533 /* do_sigaltstack() returns target values and errnos. */
534 /* compare linux/kernel/signal.c:do_sigaltstack() */
535 abi_long
do_sigaltstack(abi_ulong uss_addr
, abi_ulong uoss_addr
, abi_ulong sp
)
538 struct target_sigaltstack oss
;
540 /* XXX: test errors */
543 __put_user(target_sigaltstack_used
.ss_sp
, &oss
.ss_sp
);
544 __put_user(target_sigaltstack_used
.ss_size
, &oss
.ss_size
);
545 __put_user(sas_ss_flags(sp
), &oss
.ss_flags
);
550 struct target_sigaltstack
*uss
;
551 struct target_sigaltstack ss
;
553 ret
= -TARGET_EFAULT
;
554 if (!lock_user_struct(VERIFY_READ
, uss
, uss_addr
, 1)
555 || __get_user(ss
.ss_sp
, &uss
->ss_sp
)
556 || __get_user(ss
.ss_size
, &uss
->ss_size
)
557 || __get_user(ss
.ss_flags
, &uss
->ss_flags
))
559 unlock_user_struct(uss
, uss_addr
, 0);
562 if (on_sig_stack(sp
))
565 ret
= -TARGET_EINVAL
;
566 if (ss
.ss_flags
!= TARGET_SS_DISABLE
567 && ss
.ss_flags
!= TARGET_SS_ONSTACK
571 if (ss
.ss_flags
== TARGET_SS_DISABLE
) {
575 ret
= -TARGET_ENOMEM
;
576 if (ss
.ss_size
< MINSIGSTKSZ
)
580 target_sigaltstack_used
.ss_sp
= ss
.ss_sp
;
581 target_sigaltstack_used
.ss_size
= ss
.ss_size
;
585 ret
= -TARGET_EFAULT
;
586 if (copy_to_user(uoss_addr
, &oss
, sizeof(oss
)))
595 /* do_sigaction() return host values and errnos */
596 int do_sigaction(int sig
, const struct target_sigaction
*act
,
597 struct target_sigaction
*oact
)
599 struct target_sigaction
*k
;
600 struct sigaction act1
;
604 if (sig
< 1 || sig
> TARGET_NSIG
|| sig
== TARGET_SIGKILL
|| sig
== TARGET_SIGSTOP
)
606 k
= &sigact_table
[sig
- 1];
607 #if defined(DEBUG_SIGNAL)
608 fprintf(stderr
, "sigaction sig=%d act=0x%p, oact=0x%p\n",
612 __put_user(k
->_sa_handler
, &oact
->_sa_handler
);
613 __put_user(k
->sa_flags
, &oact
->sa_flags
);
614 #if !defined(TARGET_MIPS)
615 __put_user(k
->sa_restorer
, &oact
->sa_restorer
);
618 oact
->sa_mask
= k
->sa_mask
;
621 /* FIXME: This is not threadsafe. */
622 __get_user(k
->_sa_handler
, &act
->_sa_handler
);
623 __get_user(k
->sa_flags
, &act
->sa_flags
);
624 #if !defined(TARGET_MIPS)
625 __get_user(k
->sa_restorer
, &act
->sa_restorer
);
627 /* To be swapped in target_to_host_sigset. */
628 k
->sa_mask
= act
->sa_mask
;
630 /* we update the host linux signal state */
631 host_sig
= target_to_host_signal(sig
);
632 if (host_sig
!= SIGSEGV
&& host_sig
!= SIGBUS
) {
633 sigfillset(&act1
.sa_mask
);
634 act1
.sa_flags
= SA_SIGINFO
;
635 if (k
->sa_flags
& TARGET_SA_RESTART
)
636 act1
.sa_flags
|= SA_RESTART
;
637 /* NOTE: it is important to update the host kernel signal
638 ignore state to avoid getting unexpected interrupted
640 if (k
->_sa_handler
== TARGET_SIG_IGN
) {
641 act1
.sa_sigaction
= (void *)SIG_IGN
;
642 } else if (k
->_sa_handler
== TARGET_SIG_DFL
) {
643 if (fatal_signal (sig
))
644 act1
.sa_sigaction
= host_signal_handler
;
646 act1
.sa_sigaction
= (void *)SIG_DFL
;
648 act1
.sa_sigaction
= host_signal_handler
;
650 ret
= sigaction(host_sig
, &act1
, NULL
);
656 static inline int copy_siginfo_to_user(target_siginfo_t
*tinfo
,
657 const target_siginfo_t
*info
)
659 tswap_siginfo(tinfo
, info
);
663 static inline int current_exec_domain_sig(int sig
)
665 return /* current->exec_domain && current->exec_domain->signal_invmap
666 && sig < 32 ? current->exec_domain->signal_invmap[sig] : */ sig
;
669 #if defined(TARGET_I386) && TARGET_ABI_BITS == 32
671 /* from the Linux kernel */
673 struct target_fpreg
{
674 uint16_t significand
[4];
678 struct target_fpxreg
{
679 uint16_t significand
[4];
684 struct target_xmmreg
{
685 abi_ulong element
[4];
688 struct target_fpstate
{
689 /* Regular FPU environment */
697 struct target_fpreg _st
[8];
699 uint16_t magic
; /* 0xffff = regular FPU data only */
701 /* FXSR FPU environment */
702 abi_ulong _fxsr_env
[6]; /* FXSR FPU env is ignored */
705 struct target_fpxreg _fxsr_st
[8]; /* FXSR FPU reg data is ignored */
706 struct target_xmmreg _xmm
[8];
707 abi_ulong padding
[56];
710 #define X86_FXSR_MAGIC 0x0000
712 struct target_sigcontext
{
730 abi_ulong esp_at_signal
;
732 abi_ulong fpstate
; /* pointer */
737 struct target_ucontext
{
740 target_stack_t tuc_stack
;
741 struct target_sigcontext tuc_mcontext
;
742 target_sigset_t tuc_sigmask
; /* mask last for extensibility */
749 struct target_sigcontext sc
;
750 struct target_fpstate fpstate
;
751 abi_ulong extramask
[TARGET_NSIG_WORDS
-1];
761 struct target_siginfo info
;
762 struct target_ucontext uc
;
763 struct target_fpstate fpstate
;
768 * Set up a signal frame.
771 /* XXX: save x87 state */
773 setup_sigcontext(struct target_sigcontext
*sc
, struct target_fpstate
*fpstate
,
774 CPUX86State
*env
, abi_ulong mask
, abi_ulong fpstate_addr
)
779 /* already locked in setup_frame() */
780 err
|= __put_user(env
->segs
[R_GS
].selector
, (unsigned int *)&sc
->gs
);
781 err
|= __put_user(env
->segs
[R_FS
].selector
, (unsigned int *)&sc
->fs
);
782 err
|= __put_user(env
->segs
[R_ES
].selector
, (unsigned int *)&sc
->es
);
783 err
|= __put_user(env
->segs
[R_DS
].selector
, (unsigned int *)&sc
->ds
);
784 err
|= __put_user(env
->regs
[R_EDI
], &sc
->edi
);
785 err
|= __put_user(env
->regs
[R_ESI
], &sc
->esi
);
786 err
|= __put_user(env
->regs
[R_EBP
], &sc
->ebp
);
787 err
|= __put_user(env
->regs
[R_ESP
], &sc
->esp
);
788 err
|= __put_user(env
->regs
[R_EBX
], &sc
->ebx
);
789 err
|= __put_user(env
->regs
[R_EDX
], &sc
->edx
);
790 err
|= __put_user(env
->regs
[R_ECX
], &sc
->ecx
);
791 err
|= __put_user(env
->regs
[R_EAX
], &sc
->eax
);
792 err
|= __put_user(env
->exception_index
, &sc
->trapno
);
793 err
|= __put_user(env
->error_code
, &sc
->err
);
794 err
|= __put_user(env
->eip
, &sc
->eip
);
795 err
|= __put_user(env
->segs
[R_CS
].selector
, (unsigned int *)&sc
->cs
);
796 err
|= __put_user(env
->eflags
, &sc
->eflags
);
797 err
|= __put_user(env
->regs
[R_ESP
], &sc
->esp_at_signal
);
798 err
|= __put_user(env
->segs
[R_SS
].selector
, (unsigned int *)&sc
->ss
);
800 cpu_x86_fsave(env
, fpstate_addr
, 1);
801 fpstate
->status
= fpstate
->sw
;
803 err
|= __put_user(magic
, &fpstate
->magic
);
804 err
|= __put_user(fpstate_addr
, &sc
->fpstate
);
806 /* non-iBCS2 extensions.. */
807 err
|= __put_user(mask
, &sc
->oldmask
);
808 err
|= __put_user(env
->cr
[2], &sc
->cr2
);
813 * Determine which stack to use..
816 static inline abi_ulong
817 get_sigframe(struct target_sigaction
*ka
, CPUX86State
*env
, size_t frame_size
)
821 /* Default to using normal stack */
822 esp
= env
->regs
[R_ESP
];
823 /* This is the X/Open sanctioned signal stack switching. */
824 if (ka
->sa_flags
& TARGET_SA_ONSTACK
) {
825 if (sas_ss_flags(esp
) == 0)
826 esp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
829 /* This is the legacy signal stack switching. */
831 if ((env
->segs
[R_SS
].selector
& 0xffff) != __USER_DS
&&
832 !(ka
->sa_flags
& TARGET_SA_RESTORER
) &&
834 esp
= (unsigned long) ka
->sa_restorer
;
836 return (esp
- frame_size
) & -8ul;
839 /* compare linux/arch/i386/kernel/signal.c:setup_frame() */
840 static void setup_frame(int sig
, struct target_sigaction
*ka
,
841 target_sigset_t
*set
, CPUX86State
*env
)
843 abi_ulong frame_addr
;
844 struct sigframe
*frame
;
847 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
849 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
852 err
|= __put_user(current_exec_domain_sig(sig
),
857 setup_sigcontext(&frame
->sc
, &frame
->fpstate
, env
, set
->sig
[0],
858 frame_addr
+ offsetof(struct sigframe
, fpstate
));
862 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
863 if (__put_user(set
->sig
[i
], &frame
->extramask
[i
- 1]))
867 /* Set up to return from userspace. If provided, use a stub
868 already in userspace. */
869 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
870 err
|= __put_user(ka
->sa_restorer
, &frame
->pretcode
);
873 abi_ulong retcode_addr
;
874 retcode_addr
= frame_addr
+ offsetof(struct sigframe
, retcode
);
875 err
|= __put_user(retcode_addr
, &frame
->pretcode
);
876 /* This is popl %eax ; movl $,%eax ; int $0x80 */
878 err
|= __put_user(val16
, (uint16_t *)(frame
->retcode
+0));
879 err
|= __put_user(TARGET_NR_sigreturn
, (int *)(frame
->retcode
+2));
881 err
|= __put_user(val16
, (uint16_t *)(frame
->retcode
+6));
887 /* Set up registers for signal handler */
888 env
->regs
[R_ESP
] = frame_addr
;
889 env
->eip
= ka
->_sa_handler
;
891 cpu_x86_load_seg(env
, R_DS
, __USER_DS
);
892 cpu_x86_load_seg(env
, R_ES
, __USER_DS
);
893 cpu_x86_load_seg(env
, R_SS
, __USER_DS
);
894 cpu_x86_load_seg(env
, R_CS
, __USER_CS
);
895 env
->eflags
&= ~TF_MASK
;
897 unlock_user_struct(frame
, frame_addr
, 1);
902 unlock_user_struct(frame
, frame_addr
, 1);
903 if (sig
== TARGET_SIGSEGV
)
904 ka
->_sa_handler
= TARGET_SIG_DFL
;
905 force_sig(TARGET_SIGSEGV
/* , current */);
908 /* compare linux/arch/i386/kernel/signal.c:setup_rt_frame() */
909 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
910 target_siginfo_t
*info
,
911 target_sigset_t
*set
, CPUX86State
*env
)
913 abi_ulong frame_addr
, addr
;
914 struct rt_sigframe
*frame
;
917 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
919 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
922 err
|= __put_user(current_exec_domain_sig(sig
),
924 addr
= frame_addr
+ offsetof(struct rt_sigframe
, info
);
925 err
|= __put_user(addr
, &frame
->pinfo
);
926 addr
= frame_addr
+ offsetof(struct rt_sigframe
, uc
);
927 err
|= __put_user(addr
, &frame
->puc
);
928 err
|= copy_siginfo_to_user(&frame
->info
, info
);
932 /* Create the ucontext. */
933 err
|= __put_user(0, &frame
->uc
.tuc_flags
);
934 err
|= __put_user(0, &frame
->uc
.tuc_link
);
935 err
|= __put_user(target_sigaltstack_used
.ss_sp
,
936 &frame
->uc
.tuc_stack
.ss_sp
);
937 err
|= __put_user(sas_ss_flags(get_sp_from_cpustate(env
)),
938 &frame
->uc
.tuc_stack
.ss_flags
);
939 err
|= __put_user(target_sigaltstack_used
.ss_size
,
940 &frame
->uc
.tuc_stack
.ss_size
);
941 err
|= setup_sigcontext(&frame
->uc
.tuc_mcontext
, &frame
->fpstate
,
943 frame_addr
+ offsetof(struct rt_sigframe
, fpstate
));
944 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
945 if (__put_user(set
->sig
[i
], &frame
->uc
.tuc_sigmask
.sig
[i
]))
949 /* Set up to return from userspace. If provided, use a stub
950 already in userspace. */
951 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
952 err
|= __put_user(ka
->sa_restorer
, &frame
->pretcode
);
955 addr
= frame_addr
+ offsetof(struct rt_sigframe
, retcode
);
956 err
|= __put_user(addr
, &frame
->pretcode
);
957 /* This is movl $,%eax ; int $0x80 */
958 err
|= __put_user(0xb8, (char *)(frame
->retcode
+0));
959 err
|= __put_user(TARGET_NR_rt_sigreturn
, (int *)(frame
->retcode
+1));
961 err
|= __put_user(val16
, (uint16_t *)(frame
->retcode
+5));
967 /* Set up registers for signal handler */
968 env
->regs
[R_ESP
] = frame_addr
;
969 env
->eip
= ka
->_sa_handler
;
971 cpu_x86_load_seg(env
, R_DS
, __USER_DS
);
972 cpu_x86_load_seg(env
, R_ES
, __USER_DS
);
973 cpu_x86_load_seg(env
, R_SS
, __USER_DS
);
974 cpu_x86_load_seg(env
, R_CS
, __USER_CS
);
975 env
->eflags
&= ~TF_MASK
;
977 unlock_user_struct(frame
, frame_addr
, 1);
982 unlock_user_struct(frame
, frame_addr
, 1);
983 if (sig
== TARGET_SIGSEGV
)
984 ka
->_sa_handler
= TARGET_SIG_DFL
;
985 force_sig(TARGET_SIGSEGV
/* , current */);
989 restore_sigcontext(CPUX86State
*env
, struct target_sigcontext
*sc
, int *peax
)
991 unsigned int err
= 0;
992 abi_ulong fpstate_addr
;
993 unsigned int tmpflags
;
995 cpu_x86_load_seg(env
, R_GS
, tswap16(sc
->gs
));
996 cpu_x86_load_seg(env
, R_FS
, tswap16(sc
->fs
));
997 cpu_x86_load_seg(env
, R_ES
, tswap16(sc
->es
));
998 cpu_x86_load_seg(env
, R_DS
, tswap16(sc
->ds
));
1000 env
->regs
[R_EDI
] = tswapl(sc
->edi
);
1001 env
->regs
[R_ESI
] = tswapl(sc
->esi
);
1002 env
->regs
[R_EBP
] = tswapl(sc
->ebp
);
1003 env
->regs
[R_ESP
] = tswapl(sc
->esp
);
1004 env
->regs
[R_EBX
] = tswapl(sc
->ebx
);
1005 env
->regs
[R_EDX
] = tswapl(sc
->edx
);
1006 env
->regs
[R_ECX
] = tswapl(sc
->ecx
);
1007 env
->eip
= tswapl(sc
->eip
);
1009 cpu_x86_load_seg(env
, R_CS
, lduw_p(&sc
->cs
) | 3);
1010 cpu_x86_load_seg(env
, R_SS
, lduw_p(&sc
->ss
) | 3);
1012 tmpflags
= tswapl(sc
->eflags
);
1013 env
->eflags
= (env
->eflags
& ~0x40DD5) | (tmpflags
& 0x40DD5);
1014 // regs->orig_eax = -1; /* disable syscall checks */
1016 fpstate_addr
= tswapl(sc
->fpstate
);
1017 if (fpstate_addr
!= 0) {
1018 if (!access_ok(VERIFY_READ
, fpstate_addr
,
1019 sizeof(struct target_fpstate
)))
1021 cpu_x86_frstor(env
, fpstate_addr
, 1);
1024 *peax
= tswapl(sc
->eax
);
1030 long do_sigreturn(CPUX86State
*env
)
1032 struct sigframe
*frame
;
1033 abi_ulong frame_addr
= env
->regs
[R_ESP
] - 8;
1034 target_sigset_t target_set
;
1038 #if defined(DEBUG_SIGNAL)
1039 fprintf(stderr
, "do_sigreturn\n");
1041 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
1043 /* set blocked signals */
1044 if (__get_user(target_set
.sig
[0], &frame
->sc
.oldmask
))
1046 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
1047 if (__get_user(target_set
.sig
[i
], &frame
->extramask
[i
- 1]))
1051 target_to_host_sigset_internal(&set
, &target_set
);
1052 sigprocmask(SIG_SETMASK
, &set
, NULL
);
1054 /* restore registers */
1055 if (restore_sigcontext(env
, &frame
->sc
, &eax
))
1057 unlock_user_struct(frame
, frame_addr
, 0);
1061 unlock_user_struct(frame
, frame_addr
, 0);
1062 force_sig(TARGET_SIGSEGV
);
1066 long do_rt_sigreturn(CPUX86State
*env
)
1068 abi_ulong frame_addr
;
1069 struct rt_sigframe
*frame
;
1073 frame_addr
= env
->regs
[R_ESP
] - 4;
1074 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
1076 target_to_host_sigset(&set
, &frame
->uc
.tuc_sigmask
);
1077 sigprocmask(SIG_SETMASK
, &set
, NULL
);
1079 if (restore_sigcontext(env
, &frame
->uc
.tuc_mcontext
, &eax
))
1082 if (do_sigaltstack(frame_addr
+ offsetof(struct rt_sigframe
, uc
.tuc_stack
), 0,
1083 get_sp_from_cpustate(env
)) == -EFAULT
)
1086 unlock_user_struct(frame
, frame_addr
, 0);
1090 unlock_user_struct(frame
, frame_addr
, 0);
1091 force_sig(TARGET_SIGSEGV
);
1095 #elif defined(TARGET_AARCH64)
1097 struct target_sigcontext
{
1098 uint64_t fault_address
;
1099 /* AArch64 registers */
1104 /* 4K reserved for FP/SIMD state and future expansion */
1105 char __reserved
[4096] __attribute__((__aligned__(16)));
1108 struct target_ucontext
{
1109 abi_ulong tuc_flags
;
1111 target_stack_t tuc_stack
;
1112 target_sigset_t tuc_sigmask
;
1113 /* glibc uses a 1024-bit sigset_t */
1114 char __unused
[1024 / 8 - sizeof(target_sigset_t
)];
1115 /* last for future expansion */
1116 struct target_sigcontext tuc_mcontext
;
1120 * Header to be used at the beginning of structures extending the user
1121 * context. Such structures must be placed after the rt_sigframe on the stack
1122 * and be 16-byte aligned. The last structure must be a dummy one with the
1123 * magic and size set to 0.
1125 struct target_aarch64_ctx
{
1130 #define TARGET_FPSIMD_MAGIC 0x46508001
1132 struct target_fpsimd_context
{
1133 struct target_aarch64_ctx head
;
1136 uint64_t vregs
[32 * 2]; /* really uint128_t vregs[32] */
1140 * Auxiliary context saved in the sigcontext.__reserved array. Not exported to
1141 * user space as it will change with the addition of new context. User space
1142 * should check the magic/size information.
1144 struct target_aux_context
{
1145 struct target_fpsimd_context fpsimd
;
1146 /* additional context to be added before "end" */
1147 struct target_aarch64_ctx end
;
1150 struct target_rt_sigframe
{
1151 struct target_siginfo info
;
1152 struct target_ucontext uc
;
1158 static int target_setup_sigframe(struct target_rt_sigframe
*sf
,
1159 CPUARMState
*env
, target_sigset_t
*set
)
1162 struct target_aux_context
*aux
=
1163 (struct target_aux_context
*)sf
->uc
.tuc_mcontext
.__reserved
;
1165 /* set up the stack frame for unwinding */
1166 __put_user(env
->xregs
[29], &sf
->fp
);
1167 __put_user(env
->xregs
[30], &sf
->lr
);
1169 for (i
= 0; i
< 31; i
++) {
1170 __put_user(env
->xregs
[i
], &sf
->uc
.tuc_mcontext
.regs
[i
]);
1172 __put_user(env
->xregs
[31], &sf
->uc
.tuc_mcontext
.sp
);
1173 __put_user(env
->pc
, &sf
->uc
.tuc_mcontext
.pc
);
1174 __put_user(pstate_read(env
), &sf
->uc
.tuc_mcontext
.pstate
);
1176 __put_user(/*current->thread.fault_address*/ 0,
1177 &sf
->uc
.tuc_mcontext
.fault_address
);
1179 for (i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
1180 __put_user(set
->sig
[i
], &sf
->uc
.tuc_sigmask
.sig
[i
]);
1183 for (i
= 0; i
< 32; i
++) {
1184 #ifdef TARGET_WORDS_BIGENDIAN
1185 __put_user(env
->vfp
.regs
[i
* 2], &aux
->fpsimd
.vregs
[i
* 2 + 1]);
1186 __put_user(env
->vfp
.regs
[i
* 2 + 1], &aux
->fpsimd
.vregs
[i
* 2]);
1188 __put_user(env
->vfp
.regs
[i
* 2], &aux
->fpsimd
.vregs
[i
* 2]);
1189 __put_user(env
->vfp
.regs
[i
* 2 + 1], &aux
->fpsimd
.vregs
[i
* 2 + 1]);
1192 __put_user(/*env->fpsr*/0, &aux
->fpsimd
.fpsr
);
1193 __put_user(/*env->fpcr*/0, &aux
->fpsimd
.fpcr
);
1194 __put_user(TARGET_FPSIMD_MAGIC
, &aux
->fpsimd
.head
.magic
);
1195 __put_user(sizeof(struct target_fpsimd_context
),
1196 &aux
->fpsimd
.head
.size
);
1198 /* set the "end" magic */
1199 __put_user(0, &aux
->end
.magic
);
1200 __put_user(0, &aux
->end
.size
);
1205 static int target_restore_sigframe(CPUARMState
*env
,
1206 struct target_rt_sigframe
*sf
)
1210 struct target_aux_context
*aux
=
1211 (struct target_aux_context
*)sf
->uc
.tuc_mcontext
.__reserved
;
1212 uint32_t magic
, size
;
1215 target_to_host_sigset(&set
, &sf
->uc
.tuc_sigmask
);
1216 sigprocmask(SIG_SETMASK
, &set
, NULL
);
1218 for (i
= 0; i
< 31; i
++) {
1219 __get_user(env
->xregs
[i
], &sf
->uc
.tuc_mcontext
.regs
[i
]);
1222 __get_user(env
->xregs
[31], &sf
->uc
.tuc_mcontext
.sp
);
1223 __get_user(env
->pc
, &sf
->uc
.tuc_mcontext
.pc
);
1224 __get_user(pstate
, &sf
->uc
.tuc_mcontext
.pstate
);
1225 pstate_write(env
, pstate
);
1227 __get_user(magic
, &aux
->fpsimd
.head
.magic
);
1228 __get_user(size
, &aux
->fpsimd
.head
.size
);
1230 if (magic
!= TARGET_FPSIMD_MAGIC
1231 || size
!= sizeof(struct target_fpsimd_context
)) {
1235 for (i
= 0; i
< 32 * 2; i
++) {
1236 __get_user(env
->vfp
.regs
[i
], &aux
->fpsimd
.vregs
[i
]);
1242 static abi_ulong
get_sigframe(struct target_sigaction
*ka
, CPUARMState
*env
)
1246 sp
= env
->xregs
[31];
1249 * This is the X/Open sanctioned signal stack switching.
1251 if ((ka
->sa_flags
& SA_ONSTACK
) && !sas_ss_flags(sp
)) {
1252 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
1255 sp
= (sp
- sizeof(struct target_rt_sigframe
)) & ~15;
1260 static void target_setup_frame(int usig
, struct target_sigaction
*ka
,
1261 target_siginfo_t
*info
, target_sigset_t
*set
,
1264 struct target_rt_sigframe
*frame
;
1265 abi_ulong frame_addr
;
1267 frame_addr
= get_sigframe(ka
, env
);
1268 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0)) {
1272 __put_user(0, &frame
->uc
.tuc_flags
);
1273 __put_user(0, &frame
->uc
.tuc_link
);
1275 __put_user(target_sigaltstack_used
.ss_sp
,
1276 &frame
->uc
.tuc_stack
.ss_sp
);
1277 __put_user(sas_ss_flags(env
->xregs
[31]),
1278 &frame
->uc
.tuc_stack
.ss_flags
);
1279 __put_user(target_sigaltstack_used
.ss_size
,
1280 &frame
->uc
.tuc_stack
.ss_size
);
1281 target_setup_sigframe(frame
, env
, set
);
1282 /* mov x8,#__NR_rt_sigreturn; svc #0 */
1283 __put_user(0xd2801168, &frame
->tramp
[0]);
1284 __put_user(0xd4000001, &frame
->tramp
[1]);
1285 env
->xregs
[0] = usig
;
1286 env
->xregs
[31] = frame_addr
;
1287 env
->xregs
[29] = env
->xregs
[31] + offsetof(struct target_rt_sigframe
, fp
);
1288 env
->pc
= ka
->_sa_handler
;
1289 env
->xregs
[30] = env
->xregs
[31] +
1290 offsetof(struct target_rt_sigframe
, tramp
);
1292 if (copy_siginfo_to_user(&frame
->info
, info
)) {
1295 env
->xregs
[1] = frame_addr
+ offsetof(struct target_rt_sigframe
, info
);
1296 env
->xregs
[2] = frame_addr
+ offsetof(struct target_rt_sigframe
, uc
);
1299 unlock_user_struct(frame
, frame_addr
, 1);
1303 unlock_user_struct(frame
, frame_addr
, 1);
1304 force_sig(TARGET_SIGSEGV
);
1307 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
1308 target_siginfo_t
*info
, target_sigset_t
*set
,
1311 target_setup_frame(sig
, ka
, info
, set
, env
);
1314 static void setup_frame(int sig
, struct target_sigaction
*ka
,
1315 target_sigset_t
*set
, CPUARMState
*env
)
1317 target_setup_frame(sig
, ka
, 0, set
, env
);
1320 long do_rt_sigreturn(CPUARMState
*env
)
1322 struct target_rt_sigframe
*frame
;
1323 abi_ulong frame_addr
= env
->xregs
[31];
1325 if (frame_addr
& 15) {
1329 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1)) {
1333 if (target_restore_sigframe(env
, frame
)) {
1337 if (do_sigaltstack(frame_addr
+
1338 offsetof(struct target_rt_sigframe
, uc
.tuc_stack
),
1339 0, get_sp_from_cpustate(env
)) == -EFAULT
) {
1343 unlock_user_struct(frame
, frame_addr
, 0);
1344 return env
->xregs
[0];
1347 unlock_user_struct(frame
, frame_addr
, 0);
1348 force_sig(TARGET_SIGSEGV
);
1352 long do_sigreturn(CPUARMState
*env
)
1354 return do_rt_sigreturn(env
);
1357 #elif defined(TARGET_ARM)
1359 struct target_sigcontext
{
1361 abi_ulong error_code
;
1380 abi_ulong fault_address
;
1383 struct target_ucontext_v1
{
1384 abi_ulong tuc_flags
;
1386 target_stack_t tuc_stack
;
1387 struct target_sigcontext tuc_mcontext
;
1388 target_sigset_t tuc_sigmask
; /* mask last for extensibility */
1391 struct target_ucontext_v2
{
1392 abi_ulong tuc_flags
;
1394 target_stack_t tuc_stack
;
1395 struct target_sigcontext tuc_mcontext
;
1396 target_sigset_t tuc_sigmask
; /* mask last for extensibility */
1397 char __unused
[128 - sizeof(target_sigset_t
)];
1398 abi_ulong tuc_regspace
[128] __attribute__((__aligned__(8)));
1401 struct target_user_vfp
{
1402 uint64_t fpregs
[32];
1406 struct target_user_vfp_exc
{
1412 struct target_vfp_sigframe
{
1415 struct target_user_vfp ufp
;
1416 struct target_user_vfp_exc ufp_exc
;
1417 } __attribute__((__aligned__(8)));
1419 struct target_iwmmxt_sigframe
{
1423 /* Note that not all the coprocessor control registers are stored here */
1430 } __attribute__((__aligned__(8)));
1432 #define TARGET_VFP_MAGIC 0x56465001
1433 #define TARGET_IWMMXT_MAGIC 0x12ef842a
1437 struct target_sigcontext sc
;
1438 abi_ulong extramask
[TARGET_NSIG_WORDS
-1];
1444 struct target_ucontext_v2 uc
;
1448 struct rt_sigframe_v1
1452 struct target_siginfo info
;
1453 struct target_ucontext_v1 uc
;
1457 struct rt_sigframe_v2
1459 struct target_siginfo info
;
1460 struct target_ucontext_v2 uc
;
1464 #define TARGET_CONFIG_CPU_32 1
1467 * For ARM syscalls, we encode the syscall number into the instruction.
1469 #define SWI_SYS_SIGRETURN (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
1470 #define SWI_SYS_RT_SIGRETURN (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
1473 * For Thumb syscalls, we pass the syscall number via r7. We therefore
1474 * need two 16-bit instructions.
1476 #define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
1477 #define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
1479 static const abi_ulong retcodes
[4] = {
1480 SWI_SYS_SIGRETURN
, SWI_THUMB_SIGRETURN
,
1481 SWI_SYS_RT_SIGRETURN
, SWI_THUMB_RT_SIGRETURN
1485 #define __get_user_error(x,p,e) __get_user(x, p)
1487 static inline int valid_user_regs(CPUARMState
*regs
)
1493 setup_sigcontext(struct target_sigcontext
*sc
, /*struct _fpstate *fpstate,*/
1494 CPUARMState
*env
, abi_ulong mask
)
1496 __put_user(env
->regs
[0], &sc
->arm_r0
);
1497 __put_user(env
->regs
[1], &sc
->arm_r1
);
1498 __put_user(env
->regs
[2], &sc
->arm_r2
);
1499 __put_user(env
->regs
[3], &sc
->arm_r3
);
1500 __put_user(env
->regs
[4], &sc
->arm_r4
);
1501 __put_user(env
->regs
[5], &sc
->arm_r5
);
1502 __put_user(env
->regs
[6], &sc
->arm_r6
);
1503 __put_user(env
->regs
[7], &sc
->arm_r7
);
1504 __put_user(env
->regs
[8], &sc
->arm_r8
);
1505 __put_user(env
->regs
[9], &sc
->arm_r9
);
1506 __put_user(env
->regs
[10], &sc
->arm_r10
);
1507 __put_user(env
->regs
[11], &sc
->arm_fp
);
1508 __put_user(env
->regs
[12], &sc
->arm_ip
);
1509 __put_user(env
->regs
[13], &sc
->arm_sp
);
1510 __put_user(env
->regs
[14], &sc
->arm_lr
);
1511 __put_user(env
->regs
[15], &sc
->arm_pc
);
1512 #ifdef TARGET_CONFIG_CPU_32
1513 __put_user(cpsr_read(env
), &sc
->arm_cpsr
);
1516 __put_user(/* current->thread.trap_no */ 0, &sc
->trap_no
);
1517 __put_user(/* current->thread.error_code */ 0, &sc
->error_code
);
1518 __put_user(/* current->thread.address */ 0, &sc
->fault_address
);
1519 __put_user(mask
, &sc
->oldmask
);
1522 static inline abi_ulong
1523 get_sigframe(struct target_sigaction
*ka
, CPUARMState
*regs
, int framesize
)
1525 unsigned long sp
= regs
->regs
[13];
1528 * This is the X/Open sanctioned signal stack switching.
1530 if ((ka
->sa_flags
& TARGET_SA_ONSTACK
) && !sas_ss_flags(sp
))
1531 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
1533 * ATPCS B01 mandates 8-byte alignment
1535 return (sp
- framesize
) & ~7;
1539 setup_return(CPUARMState
*env
, struct target_sigaction
*ka
,
1540 abi_ulong
*rc
, abi_ulong frame_addr
, int usig
, abi_ulong rc_addr
)
1542 abi_ulong handler
= ka
->_sa_handler
;
1544 int thumb
= handler
& 1;
1545 uint32_t cpsr
= cpsr_read(env
);
1554 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
1555 retcode
= ka
->sa_restorer
;
1557 unsigned int idx
= thumb
;
1559 if (ka
->sa_flags
& TARGET_SA_SIGINFO
)
1562 if (__put_user(retcodes
[idx
], rc
))
1565 retcode
= rc_addr
+ thumb
;
1568 env
->regs
[0] = usig
;
1569 env
->regs
[13] = frame_addr
;
1570 env
->regs
[14] = retcode
;
1571 env
->regs
[15] = handler
& (thumb
? ~1 : ~3);
1572 cpsr_write(env
, cpsr
, 0xffffffff);
1577 static abi_ulong
*setup_sigframe_v2_vfp(abi_ulong
*regspace
, CPUARMState
*env
)
1580 struct target_vfp_sigframe
*vfpframe
;
1581 vfpframe
= (struct target_vfp_sigframe
*)regspace
;
1582 __put_user(TARGET_VFP_MAGIC
, &vfpframe
->magic
);
1583 __put_user(sizeof(*vfpframe
), &vfpframe
->size
);
1584 for (i
= 0; i
< 32; i
++) {
1585 __put_user(float64_val(env
->vfp
.regs
[i
]), &vfpframe
->ufp
.fpregs
[i
]);
1587 __put_user(vfp_get_fpscr(env
), &vfpframe
->ufp
.fpscr
);
1588 __put_user(env
->vfp
.xregs
[ARM_VFP_FPEXC
], &vfpframe
->ufp_exc
.fpexc
);
1589 __put_user(env
->vfp
.xregs
[ARM_VFP_FPINST
], &vfpframe
->ufp_exc
.fpinst
);
1590 __put_user(env
->vfp
.xregs
[ARM_VFP_FPINST2
], &vfpframe
->ufp_exc
.fpinst2
);
1591 return (abi_ulong
*)(vfpframe
+1);
1594 static abi_ulong
*setup_sigframe_v2_iwmmxt(abi_ulong
*regspace
,
1598 struct target_iwmmxt_sigframe
*iwmmxtframe
;
1599 iwmmxtframe
= (struct target_iwmmxt_sigframe
*)regspace
;
1600 __put_user(TARGET_IWMMXT_MAGIC
, &iwmmxtframe
->magic
);
1601 __put_user(sizeof(*iwmmxtframe
), &iwmmxtframe
->size
);
1602 for (i
= 0; i
< 16; i
++) {
1603 __put_user(env
->iwmmxt
.regs
[i
], &iwmmxtframe
->regs
[i
]);
1605 __put_user(env
->vfp
.xregs
[ARM_IWMMXT_wCSSF
], &iwmmxtframe
->wcssf
);
1606 __put_user(env
->vfp
.xregs
[ARM_IWMMXT_wCASF
], &iwmmxtframe
->wcssf
);
1607 __put_user(env
->vfp
.xregs
[ARM_IWMMXT_wCGR0
], &iwmmxtframe
->wcgr0
);
1608 __put_user(env
->vfp
.xregs
[ARM_IWMMXT_wCGR1
], &iwmmxtframe
->wcgr1
);
1609 __put_user(env
->vfp
.xregs
[ARM_IWMMXT_wCGR2
], &iwmmxtframe
->wcgr2
);
1610 __put_user(env
->vfp
.xregs
[ARM_IWMMXT_wCGR3
], &iwmmxtframe
->wcgr3
);
1611 return (abi_ulong
*)(iwmmxtframe
+1);
1614 static void setup_sigframe_v2(struct target_ucontext_v2
*uc
,
1615 target_sigset_t
*set
, CPUARMState
*env
)
1617 struct target_sigaltstack stack
;
1619 abi_ulong
*regspace
;
1621 /* Clear all the bits of the ucontext we don't use. */
1622 memset(uc
, 0, offsetof(struct target_ucontext_v2
, tuc_mcontext
));
1624 memset(&stack
, 0, sizeof(stack
));
1625 __put_user(target_sigaltstack_used
.ss_sp
, &stack
.ss_sp
);
1626 __put_user(target_sigaltstack_used
.ss_size
, &stack
.ss_size
);
1627 __put_user(sas_ss_flags(get_sp_from_cpustate(env
)), &stack
.ss_flags
);
1628 memcpy(&uc
->tuc_stack
, &stack
, sizeof(stack
));
1630 setup_sigcontext(&uc
->tuc_mcontext
, env
, set
->sig
[0]);
1631 /* Save coprocessor signal frame. */
1632 regspace
= uc
->tuc_regspace
;
1633 if (arm_feature(env
, ARM_FEATURE_VFP
)) {
1634 regspace
= setup_sigframe_v2_vfp(regspace
, env
);
1636 if (arm_feature(env
, ARM_FEATURE_IWMMXT
)) {
1637 regspace
= setup_sigframe_v2_iwmmxt(regspace
, env
);
1640 /* Write terminating magic word */
1641 __put_user(0, regspace
);
1643 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
1644 __put_user(set
->sig
[i
], &uc
->tuc_sigmask
.sig
[i
]);
1648 /* compare linux/arch/arm/kernel/signal.c:setup_frame() */
1649 static void setup_frame_v1(int usig
, struct target_sigaction
*ka
,
1650 target_sigset_t
*set
, CPUARMState
*regs
)
1652 struct sigframe_v1
*frame
;
1653 abi_ulong frame_addr
= get_sigframe(ka
, regs
, sizeof(*frame
));
1656 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
1659 setup_sigcontext(&frame
->sc
, regs
, set
->sig
[0]);
1661 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
1662 if (__put_user(set
->sig
[i
], &frame
->extramask
[i
- 1]))
1666 setup_return(regs
, ka
, &frame
->retcode
, frame_addr
, usig
,
1667 frame_addr
+ offsetof(struct sigframe_v1
, retcode
));
1670 unlock_user_struct(frame
, frame_addr
, 1);
1673 static void setup_frame_v2(int usig
, struct target_sigaction
*ka
,
1674 target_sigset_t
*set
, CPUARMState
*regs
)
1676 struct sigframe_v2
*frame
;
1677 abi_ulong frame_addr
= get_sigframe(ka
, regs
, sizeof(*frame
));
1679 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
1682 setup_sigframe_v2(&frame
->uc
, set
, regs
);
1684 setup_return(regs
, ka
, &frame
->retcode
, frame_addr
, usig
,
1685 frame_addr
+ offsetof(struct sigframe_v2
, retcode
));
1687 unlock_user_struct(frame
, frame_addr
, 1);
1690 static void setup_frame(int usig
, struct target_sigaction
*ka
,
1691 target_sigset_t
*set
, CPUARMState
*regs
)
1693 if (get_osversion() >= 0x020612) {
1694 setup_frame_v2(usig
, ka
, set
, regs
);
1696 setup_frame_v1(usig
, ka
, set
, regs
);
1700 /* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */
1701 static void setup_rt_frame_v1(int usig
, struct target_sigaction
*ka
,
1702 target_siginfo_t
*info
,
1703 target_sigset_t
*set
, CPUARMState
*env
)
1705 struct rt_sigframe_v1
*frame
;
1706 abi_ulong frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
1707 struct target_sigaltstack stack
;
1709 abi_ulong info_addr
, uc_addr
;
1711 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
1714 info_addr
= frame_addr
+ offsetof(struct rt_sigframe_v1
, info
);
1715 __put_user(info_addr
, &frame
->pinfo
);
1716 uc_addr
= frame_addr
+ offsetof(struct rt_sigframe_v1
, uc
);
1717 __put_user(uc_addr
, &frame
->puc
);
1718 copy_siginfo_to_user(&frame
->info
, info
);
1720 /* Clear all the bits of the ucontext we don't use. */
1721 memset(&frame
->uc
, 0, offsetof(struct target_ucontext_v1
, tuc_mcontext
));
1723 memset(&stack
, 0, sizeof(stack
));
1724 __put_user(target_sigaltstack_used
.ss_sp
, &stack
.ss_sp
);
1725 __put_user(target_sigaltstack_used
.ss_size
, &stack
.ss_size
);
1726 __put_user(sas_ss_flags(get_sp_from_cpustate(env
)), &stack
.ss_flags
);
1727 memcpy(&frame
->uc
.tuc_stack
, &stack
, sizeof(stack
));
1729 setup_sigcontext(&frame
->uc
.tuc_mcontext
, env
, set
->sig
[0]);
1730 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
1731 if (__put_user(set
->sig
[i
], &frame
->uc
.tuc_sigmask
.sig
[i
]))
1735 setup_return(env
, ka
, &frame
->retcode
, frame_addr
, usig
,
1736 frame_addr
+ offsetof(struct rt_sigframe_v1
, retcode
));
1738 env
->regs
[1] = info_addr
;
1739 env
->regs
[2] = uc_addr
;
1742 unlock_user_struct(frame
, frame_addr
, 1);
1745 static void setup_rt_frame_v2(int usig
, struct target_sigaction
*ka
,
1746 target_siginfo_t
*info
,
1747 target_sigset_t
*set
, CPUARMState
*env
)
1749 struct rt_sigframe_v2
*frame
;
1750 abi_ulong frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
1751 abi_ulong info_addr
, uc_addr
;
1753 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
1756 info_addr
= frame_addr
+ offsetof(struct rt_sigframe_v2
, info
);
1757 uc_addr
= frame_addr
+ offsetof(struct rt_sigframe_v2
, uc
);
1758 copy_siginfo_to_user(&frame
->info
, info
);
1760 setup_sigframe_v2(&frame
->uc
, set
, env
);
1762 setup_return(env
, ka
, &frame
->retcode
, frame_addr
, usig
,
1763 frame_addr
+ offsetof(struct rt_sigframe_v2
, retcode
));
1765 env
->regs
[1] = info_addr
;
1766 env
->regs
[2] = uc_addr
;
1768 unlock_user_struct(frame
, frame_addr
, 1);
1771 static void setup_rt_frame(int usig
, struct target_sigaction
*ka
,
1772 target_siginfo_t
*info
,
1773 target_sigset_t
*set
, CPUARMState
*env
)
1775 if (get_osversion() >= 0x020612) {
1776 setup_rt_frame_v2(usig
, ka
, info
, set
, env
);
1778 setup_rt_frame_v1(usig
, ka
, info
, set
, env
);
1783 restore_sigcontext(CPUARMState
*env
, struct target_sigcontext
*sc
)
1788 __get_user_error(env
->regs
[0], &sc
->arm_r0
, err
);
1789 __get_user_error(env
->regs
[1], &sc
->arm_r1
, err
);
1790 __get_user_error(env
->regs
[2], &sc
->arm_r2
, err
);
1791 __get_user_error(env
->regs
[3], &sc
->arm_r3
, err
);
1792 __get_user_error(env
->regs
[4], &sc
->arm_r4
, err
);
1793 __get_user_error(env
->regs
[5], &sc
->arm_r5
, err
);
1794 __get_user_error(env
->regs
[6], &sc
->arm_r6
, err
);
1795 __get_user_error(env
->regs
[7], &sc
->arm_r7
, err
);
1796 __get_user_error(env
->regs
[8], &sc
->arm_r8
, err
);
1797 __get_user_error(env
->regs
[9], &sc
->arm_r9
, err
);
1798 __get_user_error(env
->regs
[10], &sc
->arm_r10
, err
);
1799 __get_user_error(env
->regs
[11], &sc
->arm_fp
, err
);
1800 __get_user_error(env
->regs
[12], &sc
->arm_ip
, err
);
1801 __get_user_error(env
->regs
[13], &sc
->arm_sp
, err
);
1802 __get_user_error(env
->regs
[14], &sc
->arm_lr
, err
);
1803 __get_user_error(env
->regs
[15], &sc
->arm_pc
, err
);
1804 #ifdef TARGET_CONFIG_CPU_32
1805 __get_user_error(cpsr
, &sc
->arm_cpsr
, err
);
1806 cpsr_write(env
, cpsr
, CPSR_USER
| CPSR_EXEC
);
1809 err
|= !valid_user_regs(env
);
1814 static long do_sigreturn_v1(CPUARMState
*env
)
1816 abi_ulong frame_addr
;
1817 struct sigframe_v1
*frame
= NULL
;
1818 target_sigset_t set
;
1823 * Since we stacked the signal on a 64-bit boundary,
1824 * then 'sp' should be word aligned here. If it's
1825 * not, then the user is trying to mess with us.
1827 frame_addr
= env
->regs
[13];
1828 if (frame_addr
& 7) {
1832 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
1835 if (__get_user(set
.sig
[0], &frame
->sc
.oldmask
))
1837 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
1838 if (__get_user(set
.sig
[i
], &frame
->extramask
[i
- 1]))
1842 target_to_host_sigset_internal(&host_set
, &set
);
1843 sigprocmask(SIG_SETMASK
, &host_set
, NULL
);
1845 if (restore_sigcontext(env
, &frame
->sc
))
1849 /* Send SIGTRAP if we're single-stepping */
1850 if (ptrace_cancel_bpt(current
))
1851 send_sig(SIGTRAP
, current
, 1);
1853 unlock_user_struct(frame
, frame_addr
, 0);
1854 return env
->regs
[0];
1857 unlock_user_struct(frame
, frame_addr
, 0);
1858 force_sig(TARGET_SIGSEGV
/* , current */);
1862 static abi_ulong
*restore_sigframe_v2_vfp(CPUARMState
*env
, abi_ulong
*regspace
)
1865 abi_ulong magic
, sz
;
1866 uint32_t fpscr
, fpexc
;
1867 struct target_vfp_sigframe
*vfpframe
;
1868 vfpframe
= (struct target_vfp_sigframe
*)regspace
;
1870 __get_user(magic
, &vfpframe
->magic
);
1871 __get_user(sz
, &vfpframe
->size
);
1872 if (magic
!= TARGET_VFP_MAGIC
|| sz
!= sizeof(*vfpframe
)) {
1875 for (i
= 0; i
< 32; i
++) {
1876 __get_user(float64_val(env
->vfp
.regs
[i
]), &vfpframe
->ufp
.fpregs
[i
]);
1878 __get_user(fpscr
, &vfpframe
->ufp
.fpscr
);
1879 vfp_set_fpscr(env
, fpscr
);
1880 __get_user(fpexc
, &vfpframe
->ufp_exc
.fpexc
);
1881 /* Sanitise FPEXC: ensure VFP is enabled, FPINST2 is invalid
1882 * and the exception flag is cleared
1885 fpexc
&= ~((1 << 31) | (1 << 28));
1886 env
->vfp
.xregs
[ARM_VFP_FPEXC
] = fpexc
;
1887 __get_user(env
->vfp
.xregs
[ARM_VFP_FPINST
], &vfpframe
->ufp_exc
.fpinst
);
1888 __get_user(env
->vfp
.xregs
[ARM_VFP_FPINST2
], &vfpframe
->ufp_exc
.fpinst2
);
1889 return (abi_ulong
*)(vfpframe
+ 1);
1892 static abi_ulong
*restore_sigframe_v2_iwmmxt(CPUARMState
*env
,
1893 abi_ulong
*regspace
)
1896 abi_ulong magic
, sz
;
1897 struct target_iwmmxt_sigframe
*iwmmxtframe
;
1898 iwmmxtframe
= (struct target_iwmmxt_sigframe
*)regspace
;
1900 __get_user(magic
, &iwmmxtframe
->magic
);
1901 __get_user(sz
, &iwmmxtframe
->size
);
1902 if (magic
!= TARGET_IWMMXT_MAGIC
|| sz
!= sizeof(*iwmmxtframe
)) {
1905 for (i
= 0; i
< 16; i
++) {
1906 __get_user(env
->iwmmxt
.regs
[i
], &iwmmxtframe
->regs
[i
]);
1908 __get_user(env
->vfp
.xregs
[ARM_IWMMXT_wCSSF
], &iwmmxtframe
->wcssf
);
1909 __get_user(env
->vfp
.xregs
[ARM_IWMMXT_wCASF
], &iwmmxtframe
->wcssf
);
1910 __get_user(env
->vfp
.xregs
[ARM_IWMMXT_wCGR0
], &iwmmxtframe
->wcgr0
);
1911 __get_user(env
->vfp
.xregs
[ARM_IWMMXT_wCGR1
], &iwmmxtframe
->wcgr1
);
1912 __get_user(env
->vfp
.xregs
[ARM_IWMMXT_wCGR2
], &iwmmxtframe
->wcgr2
);
1913 __get_user(env
->vfp
.xregs
[ARM_IWMMXT_wCGR3
], &iwmmxtframe
->wcgr3
);
1914 return (abi_ulong
*)(iwmmxtframe
+ 1);
1917 static int do_sigframe_return_v2(CPUARMState
*env
, target_ulong frame_addr
,
1918 struct target_ucontext_v2
*uc
)
1921 abi_ulong
*regspace
;
1923 target_to_host_sigset(&host_set
, &uc
->tuc_sigmask
);
1924 sigprocmask(SIG_SETMASK
, &host_set
, NULL
);
1926 if (restore_sigcontext(env
, &uc
->tuc_mcontext
))
1929 /* Restore coprocessor signal frame */
1930 regspace
= uc
->tuc_regspace
;
1931 if (arm_feature(env
, ARM_FEATURE_VFP
)) {
1932 regspace
= restore_sigframe_v2_vfp(env
, regspace
);
1937 if (arm_feature(env
, ARM_FEATURE_IWMMXT
)) {
1938 regspace
= restore_sigframe_v2_iwmmxt(env
, regspace
);
1944 if (do_sigaltstack(frame_addr
+ offsetof(struct target_ucontext_v2
, tuc_stack
), 0, get_sp_from_cpustate(env
)) == -EFAULT
)
1948 /* Send SIGTRAP if we're single-stepping */
1949 if (ptrace_cancel_bpt(current
))
1950 send_sig(SIGTRAP
, current
, 1);
1956 static long do_sigreturn_v2(CPUARMState
*env
)
1958 abi_ulong frame_addr
;
1959 struct sigframe_v2
*frame
= NULL
;
1962 * Since we stacked the signal on a 64-bit boundary,
1963 * then 'sp' should be word aligned here. If it's
1964 * not, then the user is trying to mess with us.
1966 frame_addr
= env
->regs
[13];
1967 if (frame_addr
& 7) {
1971 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
1974 if (do_sigframe_return_v2(env
, frame_addr
, &frame
->uc
))
1977 unlock_user_struct(frame
, frame_addr
, 0);
1978 return env
->regs
[0];
1981 unlock_user_struct(frame
, frame_addr
, 0);
1982 force_sig(TARGET_SIGSEGV
/* , current */);
1986 long do_sigreturn(CPUARMState
*env
)
1988 if (get_osversion() >= 0x020612) {
1989 return do_sigreturn_v2(env
);
1991 return do_sigreturn_v1(env
);
1995 static long do_rt_sigreturn_v1(CPUARMState
*env
)
1997 abi_ulong frame_addr
;
1998 struct rt_sigframe_v1
*frame
= NULL
;
2002 * Since we stacked the signal on a 64-bit boundary,
2003 * then 'sp' should be word aligned here. If it's
2004 * not, then the user is trying to mess with us.
2006 frame_addr
= env
->regs
[13];
2007 if (frame_addr
& 7) {
2011 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
2014 target_to_host_sigset(&host_set
, &frame
->uc
.tuc_sigmask
);
2015 sigprocmask(SIG_SETMASK
, &host_set
, NULL
);
2017 if (restore_sigcontext(env
, &frame
->uc
.tuc_mcontext
))
2020 if (do_sigaltstack(frame_addr
+ offsetof(struct rt_sigframe_v1
, uc
.tuc_stack
), 0, get_sp_from_cpustate(env
)) == -EFAULT
)
2024 /* Send SIGTRAP if we're single-stepping */
2025 if (ptrace_cancel_bpt(current
))
2026 send_sig(SIGTRAP
, current
, 1);
2028 unlock_user_struct(frame
, frame_addr
, 0);
2029 return env
->regs
[0];
2032 unlock_user_struct(frame
, frame_addr
, 0);
2033 force_sig(TARGET_SIGSEGV
/* , current */);
2037 static long do_rt_sigreturn_v2(CPUARMState
*env
)
2039 abi_ulong frame_addr
;
2040 struct rt_sigframe_v2
*frame
= NULL
;
2043 * Since we stacked the signal on a 64-bit boundary,
2044 * then 'sp' should be word aligned here. If it's
2045 * not, then the user is trying to mess with us.
2047 frame_addr
= env
->regs
[13];
2048 if (frame_addr
& 7) {
2052 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
2055 if (do_sigframe_return_v2(env
, frame_addr
, &frame
->uc
))
2058 unlock_user_struct(frame
, frame_addr
, 0);
2059 return env
->regs
[0];
2062 unlock_user_struct(frame
, frame_addr
, 0);
2063 force_sig(TARGET_SIGSEGV
/* , current */);
2067 long do_rt_sigreturn(CPUARMState
*env
)
2069 if (get_osversion() >= 0x020612) {
2070 return do_rt_sigreturn_v2(env
);
2072 return do_rt_sigreturn_v1(env
);
2076 #elif defined(TARGET_SPARC)
2078 #define __SUNOS_MAXWIN 31
2080 /* This is what SunOS does, so shall I. */
2081 struct target_sigcontext
{
2082 abi_ulong sigc_onstack
; /* state to restore */
2084 abi_ulong sigc_mask
; /* sigmask to restore */
2085 abi_ulong sigc_sp
; /* stack pointer */
2086 abi_ulong sigc_pc
; /* program counter */
2087 abi_ulong sigc_npc
; /* next program counter */
2088 abi_ulong sigc_psr
; /* for condition codes etc */
2089 abi_ulong sigc_g1
; /* User uses these two registers */
2090 abi_ulong sigc_o0
; /* within the trampoline code. */
2092 /* Now comes information regarding the users window set
2093 * at the time of the signal.
2095 abi_ulong sigc_oswins
; /* outstanding windows */
2097 /* stack ptrs for each regwin buf */
2098 char *sigc_spbuf
[__SUNOS_MAXWIN
];
2100 /* Windows to restore after signal */
2102 abi_ulong locals
[8];
2104 } sigc_wbuf
[__SUNOS_MAXWIN
];
2106 /* A Sparc stack frame */
2107 struct sparc_stackf
{
2108 abi_ulong locals
[8];
2110 /* It's simpler to treat fp and callers_pc as elements of ins[]
2111 * since we never need to access them ourselves.
2115 abi_ulong xxargs
[1];
2124 abi_ulong u_regs
[16]; /* globals and ins */
2130 abi_ulong si_float_regs
[32];
2131 unsigned long si_fsr
;
2132 unsigned long si_fpqdepth
;
2134 unsigned long *insn_addr
;
2137 } qemu_siginfo_fpu_t
;
2140 struct target_signal_frame
{
2141 struct sparc_stackf ss
;
2144 abi_ulong insns
[2] __attribute__ ((aligned (8)));
2145 abi_ulong extramask
[TARGET_NSIG_WORDS
- 1];
2146 abi_ulong extra_size
; /* Should be 0 */
2147 qemu_siginfo_fpu_t fpu_state
;
2149 struct target_rt_signal_frame
{
2150 struct sparc_stackf ss
;
2155 unsigned int insns
[2];
2157 unsigned int extra_size
; /* Should be 0 */
2158 qemu_siginfo_fpu_t fpu_state
;
2172 #define UREG_FP UREG_I6
2173 #define UREG_SP UREG_O6
2175 static inline abi_ulong
get_sigframe(struct target_sigaction
*sa
,
2177 unsigned long framesize
)
2181 sp
= env
->regwptr
[UREG_FP
];
2183 /* This is the X/Open sanctioned signal stack switching. */
2184 if (sa
->sa_flags
& TARGET_SA_ONSTACK
) {
2185 if (!on_sig_stack(sp
)
2186 && !((target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
) & 7))
2187 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
2189 return sp
- framesize
;
2193 setup___siginfo(__siginfo_t
*si
, CPUSPARCState
*env
, abi_ulong mask
)
2197 err
|= __put_user(env
->psr
, &si
->si_regs
.psr
);
2198 err
|= __put_user(env
->pc
, &si
->si_regs
.pc
);
2199 err
|= __put_user(env
->npc
, &si
->si_regs
.npc
);
2200 err
|= __put_user(env
->y
, &si
->si_regs
.y
);
2201 for (i
=0; i
< 8; i
++) {
2202 err
|= __put_user(env
->gregs
[i
], &si
->si_regs
.u_regs
[i
]);
2204 for (i
=0; i
< 8; i
++) {
2205 err
|= __put_user(env
->regwptr
[UREG_I0
+ i
], &si
->si_regs
.u_regs
[i
+8]);
2207 err
|= __put_user(mask
, &si
->si_mask
);
2213 setup_sigcontext(struct target_sigcontext
*sc
, /*struct _fpstate *fpstate,*/
2214 CPUSPARCState
*env
, unsigned long mask
)
2218 err
|= __put_user(mask
, &sc
->sigc_mask
);
2219 err
|= __put_user(env
->regwptr
[UREG_SP
], &sc
->sigc_sp
);
2220 err
|= __put_user(env
->pc
, &sc
->sigc_pc
);
2221 err
|= __put_user(env
->npc
, &sc
->sigc_npc
);
2222 err
|= __put_user(env
->psr
, &sc
->sigc_psr
);
2223 err
|= __put_user(env
->gregs
[1], &sc
->sigc_g1
);
2224 err
|= __put_user(env
->regwptr
[UREG_O0
], &sc
->sigc_o0
);
2229 #define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7)))
2231 static void setup_frame(int sig
, struct target_sigaction
*ka
,
2232 target_sigset_t
*set
, CPUSPARCState
*env
)
2235 struct target_signal_frame
*sf
;
2236 int sigframe_size
, err
, i
;
2238 /* 1. Make sure everything is clean */
2239 //synchronize_user_stack();
2241 sigframe_size
= NF_ALIGNEDSZ
;
2242 sf_addr
= get_sigframe(ka
, env
, sigframe_size
);
2244 sf
= lock_user(VERIFY_WRITE
, sf_addr
,
2245 sizeof(struct target_signal_frame
), 0);
2249 //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
2251 if (invalid_frame_pointer(sf
, sigframe_size
))
2252 goto sigill_and_return
;
2254 /* 2. Save the current process state */
2255 err
= setup___siginfo(&sf
->info
, env
, set
->sig
[0]);
2256 err
|= __put_user(0, &sf
->extra_size
);
2258 //err |= save_fpu_state(regs, &sf->fpu_state);
2259 //err |= __put_user(&sf->fpu_state, &sf->fpu_save);
2261 err
|= __put_user(set
->sig
[0], &sf
->info
.si_mask
);
2262 for (i
= 0; i
< TARGET_NSIG_WORDS
- 1; i
++) {
2263 err
|= __put_user(set
->sig
[i
+ 1], &sf
->extramask
[i
]);
2266 for (i
= 0; i
< 8; i
++) {
2267 err
|= __put_user(env
->regwptr
[i
+ UREG_L0
], &sf
->ss
.locals
[i
]);
2269 for (i
= 0; i
< 8; i
++) {
2270 err
|= __put_user(env
->regwptr
[i
+ UREG_I0
], &sf
->ss
.ins
[i
]);
2275 /* 3. signal handler back-trampoline and parameters */
2276 env
->regwptr
[UREG_FP
] = sf_addr
;
2277 env
->regwptr
[UREG_I0
] = sig
;
2278 env
->regwptr
[UREG_I1
] = sf_addr
+
2279 offsetof(struct target_signal_frame
, info
);
2280 env
->regwptr
[UREG_I2
] = sf_addr
+
2281 offsetof(struct target_signal_frame
, info
);
2283 /* 4. signal handler */
2284 env
->pc
= ka
->_sa_handler
;
2285 env
->npc
= (env
->pc
+ 4);
2286 /* 5. return to kernel instructions */
2287 if (ka
->sa_restorer
)
2288 env
->regwptr
[UREG_I7
] = ka
->sa_restorer
;
2292 env
->regwptr
[UREG_I7
] = sf_addr
+
2293 offsetof(struct target_signal_frame
, insns
) - 2 * 4;
2295 /* mov __NR_sigreturn, %g1 */
2297 err
|= __put_user(val32
, &sf
->insns
[0]);
2301 err
|= __put_user(val32
, &sf
->insns
[1]);
2305 /* Flush instruction space. */
2306 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
2309 unlock_user(sf
, sf_addr
, sizeof(struct target_signal_frame
));
2313 force_sig(TARGET_SIGILL
);
2316 //fprintf(stderr, "force_sig\n");
2317 unlock_user(sf
, sf_addr
, sizeof(struct target_signal_frame
));
2318 force_sig(TARGET_SIGSEGV
);
2321 restore_fpu_state(CPUSPARCState
*env
, qemu_siginfo_fpu_t
*fpu
)
2326 if (current
->flags
& PF_USEDFPU
)
2327 regs
->psr
&= ~PSR_EF
;
2329 if (current
== last_task_used_math
) {
2330 last_task_used_math
= 0;
2331 regs
->psr
&= ~PSR_EF
;
2334 current
->used_math
= 1;
2335 current
->flags
&= ~PF_USEDFPU
;
2338 if (verify_area (VERIFY_READ
, fpu
, sizeof(*fpu
)))
2342 /* XXX: incorrect */
2343 err
= copy_from_user(&env
->fpr
[0], fpu
->si_float_regs
[0],
2344 (sizeof(abi_ulong
) * 32));
2345 err
|= __get_user(env
->fsr
, &fpu
->si_fsr
);
2347 err
|= __get_user(current
->thread
.fpqdepth
, &fpu
->si_fpqdepth
);
2348 if (current
->thread
.fpqdepth
!= 0)
2349 err
|= __copy_from_user(¤t
->thread
.fpqueue
[0],
2350 &fpu
->si_fpqueue
[0],
2351 ((sizeof(unsigned long) +
2352 (sizeof(unsigned long *)))*16));
2358 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
2359 target_siginfo_t
*info
,
2360 target_sigset_t
*set
, CPUSPARCState
*env
)
2362 fprintf(stderr
, "setup_rt_frame: not implemented\n");
2365 long do_sigreturn(CPUSPARCState
*env
)
2368 struct target_signal_frame
*sf
;
2369 uint32_t up_psr
, pc
, npc
;
2370 target_sigset_t set
;
2374 sf_addr
= env
->regwptr
[UREG_FP
];
2375 if (!lock_user_struct(VERIFY_READ
, sf
, sf_addr
, 1))
2378 fprintf(stderr
, "sigreturn\n");
2379 fprintf(stderr
, "sf: %x pc %x fp %x sp %x\n", sf
, env
->pc
, env
->regwptr
[UREG_FP
], env
->regwptr
[UREG_SP
]);
2381 //cpu_dump_state(env, stderr, fprintf, 0);
2383 /* 1. Make sure we are not getting garbage from the user */
2388 err
= __get_user(pc
, &sf
->info
.si_regs
.pc
);
2389 err
|= __get_user(npc
, &sf
->info
.si_regs
.npc
);
2394 /* 2. Restore the state */
2395 err
|= __get_user(up_psr
, &sf
->info
.si_regs
.psr
);
2397 /* User can only change condition codes and FPU enabling in %psr. */
2398 env
->psr
= (up_psr
& (PSR_ICC
/* | PSR_EF */))
2399 | (env
->psr
& ~(PSR_ICC
/* | PSR_EF */));
2403 err
|= __get_user(env
->y
, &sf
->info
.si_regs
.y
);
2404 for (i
=0; i
< 8; i
++) {
2405 err
|= __get_user(env
->gregs
[i
], &sf
->info
.si_regs
.u_regs
[i
]);
2407 for (i
=0; i
< 8; i
++) {
2408 err
|= __get_user(env
->regwptr
[i
+ UREG_I0
], &sf
->info
.si_regs
.u_regs
[i
+8]);
2411 /* FIXME: implement FPU save/restore:
2412 * __get_user(fpu_save, &sf->fpu_save);
2414 * err |= restore_fpu_state(env, fpu_save);
2417 /* This is pretty much atomic, no amount locking would prevent
2418 * the races which exist anyways.
2420 err
|= __get_user(set
.sig
[0], &sf
->info
.si_mask
);
2421 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
2422 err
|= (__get_user(set
.sig
[i
], &sf
->extramask
[i
- 1]));
2425 target_to_host_sigset_internal(&host_set
, &set
);
2426 sigprocmask(SIG_SETMASK
, &host_set
, NULL
);
2430 unlock_user_struct(sf
, sf_addr
, 0);
2431 return env
->regwptr
[0];
2434 unlock_user_struct(sf
, sf_addr
, 0);
2435 force_sig(TARGET_SIGSEGV
);
2438 long do_rt_sigreturn(CPUSPARCState
*env
)
2440 fprintf(stderr
, "do_rt_sigreturn: not implemented\n");
2441 return -TARGET_ENOSYS
;
2444 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
2466 typedef abi_ulong target_mc_greg_t
;
2467 typedef target_mc_greg_t target_mc_gregset_t
[MC_NGREG
];
2469 struct target_mc_fq
{
2470 abi_ulong
*mcfq_addr
;
2474 struct target_mc_fpu
{
2478 //uint128_t qregs[16];
2480 abi_ulong mcfpu_fsr
;
2481 abi_ulong mcfpu_fprs
;
2482 abi_ulong mcfpu_gsr
;
2483 struct target_mc_fq
*mcfpu_fq
;
2484 unsigned char mcfpu_qcnt
;
2485 unsigned char mcfpu_qentsz
;
2486 unsigned char mcfpu_enab
;
2488 typedef struct target_mc_fpu target_mc_fpu_t
;
2491 target_mc_gregset_t mc_gregs
;
2492 target_mc_greg_t mc_fp
;
2493 target_mc_greg_t mc_i7
;
2494 target_mc_fpu_t mc_fpregs
;
2495 } target_mcontext_t
;
2497 struct target_ucontext
{
2498 struct target_ucontext
*tuc_link
;
2499 abi_ulong tuc_flags
;
2500 target_sigset_t tuc_sigmask
;
2501 target_mcontext_t tuc_mcontext
;
2504 /* A V9 register window */
2505 struct target_reg_window
{
2506 abi_ulong locals
[8];
2510 #define TARGET_STACK_BIAS 2047
2512 /* {set, get}context() needed for 64-bit SparcLinux userland. */
2513 void sparc64_set_context(CPUSPARCState
*env
)
2516 struct target_ucontext
*ucp
;
2517 target_mc_gregset_t
*grp
;
2518 abi_ulong pc
, npc
, tstate
;
2519 abi_ulong fp
, i7
, w_addr
;
2523 ucp_addr
= env
->regwptr
[UREG_I0
];
2524 if (!lock_user_struct(VERIFY_READ
, ucp
, ucp_addr
, 1))
2526 grp
= &ucp
->tuc_mcontext
.mc_gregs
;
2527 err
= __get_user(pc
, &((*grp
)[MC_PC
]));
2528 err
|= __get_user(npc
, &((*grp
)[MC_NPC
]));
2529 if (err
|| ((pc
| npc
) & 3))
2531 if (env
->regwptr
[UREG_I1
]) {
2532 target_sigset_t target_set
;
2535 if (TARGET_NSIG_WORDS
== 1) {
2536 if (__get_user(target_set
.sig
[0], &ucp
->tuc_sigmask
.sig
[0]))
2539 abi_ulong
*src
, *dst
;
2540 src
= ucp
->tuc_sigmask
.sig
;
2541 dst
= target_set
.sig
;
2542 for (i
= 0; i
< TARGET_NSIG_WORDS
; i
++, dst
++, src
++) {
2543 err
|= __get_user(*dst
, src
);
2548 target_to_host_sigset_internal(&set
, &target_set
);
2549 sigprocmask(SIG_SETMASK
, &set
, NULL
);
2553 err
|= __get_user(env
->y
, &((*grp
)[MC_Y
]));
2554 err
|= __get_user(tstate
, &((*grp
)[MC_TSTATE
]));
2555 env
->asi
= (tstate
>> 24) & 0xff;
2556 cpu_put_ccr(env
, tstate
>> 32);
2557 cpu_put_cwp64(env
, tstate
& 0x1f);
2558 err
|= __get_user(env
->gregs
[1], (&(*grp
)[MC_G1
]));
2559 err
|= __get_user(env
->gregs
[2], (&(*grp
)[MC_G2
]));
2560 err
|= __get_user(env
->gregs
[3], (&(*grp
)[MC_G3
]));
2561 err
|= __get_user(env
->gregs
[4], (&(*grp
)[MC_G4
]));
2562 err
|= __get_user(env
->gregs
[5], (&(*grp
)[MC_G5
]));
2563 err
|= __get_user(env
->gregs
[6], (&(*grp
)[MC_G6
]));
2564 err
|= __get_user(env
->gregs
[7], (&(*grp
)[MC_G7
]));
2565 err
|= __get_user(env
->regwptr
[UREG_I0
], (&(*grp
)[MC_O0
]));
2566 err
|= __get_user(env
->regwptr
[UREG_I1
], (&(*grp
)[MC_O1
]));
2567 err
|= __get_user(env
->regwptr
[UREG_I2
], (&(*grp
)[MC_O2
]));
2568 err
|= __get_user(env
->regwptr
[UREG_I3
], (&(*grp
)[MC_O3
]));
2569 err
|= __get_user(env
->regwptr
[UREG_I4
], (&(*grp
)[MC_O4
]));
2570 err
|= __get_user(env
->regwptr
[UREG_I5
], (&(*grp
)[MC_O5
]));
2571 err
|= __get_user(env
->regwptr
[UREG_I6
], (&(*grp
)[MC_O6
]));
2572 err
|= __get_user(env
->regwptr
[UREG_I7
], (&(*grp
)[MC_O7
]));
2574 err
|= __get_user(fp
, &(ucp
->tuc_mcontext
.mc_fp
));
2575 err
|= __get_user(i7
, &(ucp
->tuc_mcontext
.mc_i7
));
2577 w_addr
= TARGET_STACK_BIAS
+env
->regwptr
[UREG_I6
];
2578 if (put_user(fp
, w_addr
+ offsetof(struct target_reg_window
, ins
[6]),
2581 if (put_user(i7
, w_addr
+ offsetof(struct target_reg_window
, ins
[7]),
2584 /* FIXME this does not match how the kernel handles the FPU in
2585 * its sparc64_set_context implementation. In particular the FPU
2586 * is only restored if fenab is non-zero in:
2587 * __get_user(fenab, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_enab));
2589 err
|= __get_user(env
->fprs
, &(ucp
->tuc_mcontext
.mc_fpregs
.mcfpu_fprs
));
2591 uint32_t *src
= ucp
->tuc_mcontext
.mc_fpregs
.mcfpu_fregs
.sregs
;
2592 for (i
= 0; i
< 64; i
++, src
++) {
2594 err
|= __get_user(env
->fpr
[i
/2].l
.lower
, src
);
2596 err
|= __get_user(env
->fpr
[i
/2].l
.upper
, src
);
2600 err
|= __get_user(env
->fsr
,
2601 &(ucp
->tuc_mcontext
.mc_fpregs
.mcfpu_fsr
));
2602 err
|= __get_user(env
->gsr
,
2603 &(ucp
->tuc_mcontext
.mc_fpregs
.mcfpu_gsr
));
2606 unlock_user_struct(ucp
, ucp_addr
, 0);
2609 unlock_user_struct(ucp
, ucp_addr
, 0);
2610 force_sig(TARGET_SIGSEGV
);
2613 void sparc64_get_context(CPUSPARCState
*env
)
2616 struct target_ucontext
*ucp
;
2617 target_mc_gregset_t
*grp
;
2618 target_mcontext_t
*mcp
;
2619 abi_ulong fp
, i7
, w_addr
;
2622 target_sigset_t target_set
;
2625 ucp_addr
= env
->regwptr
[UREG_I0
];
2626 if (!lock_user_struct(VERIFY_WRITE
, ucp
, ucp_addr
, 0))
2629 mcp
= &ucp
->tuc_mcontext
;
2630 grp
= &mcp
->mc_gregs
;
2632 /* Skip over the trap instruction, first. */
2638 sigprocmask(0, NULL
, &set
);
2639 host_to_target_sigset_internal(&target_set
, &set
);
2640 if (TARGET_NSIG_WORDS
== 1) {
2641 err
|= __put_user(target_set
.sig
[0],
2642 (abi_ulong
*)&ucp
->tuc_sigmask
);
2644 abi_ulong
*src
, *dst
;
2645 src
= target_set
.sig
;
2646 dst
= ucp
->tuc_sigmask
.sig
;
2647 for (i
= 0; i
< TARGET_NSIG_WORDS
; i
++, dst
++, src
++) {
2648 err
|= __put_user(*src
, dst
);
2654 /* XXX: tstate must be saved properly */
2655 // err |= __put_user(env->tstate, &((*grp)[MC_TSTATE]));
2656 err
|= __put_user(env
->pc
, &((*grp
)[MC_PC
]));
2657 err
|= __put_user(env
->npc
, &((*grp
)[MC_NPC
]));
2658 err
|= __put_user(env
->y
, &((*grp
)[MC_Y
]));
2659 err
|= __put_user(env
->gregs
[1], &((*grp
)[MC_G1
]));
2660 err
|= __put_user(env
->gregs
[2], &((*grp
)[MC_G2
]));
2661 err
|= __put_user(env
->gregs
[3], &((*grp
)[MC_G3
]));
2662 err
|= __put_user(env
->gregs
[4], &((*grp
)[MC_G4
]));
2663 err
|= __put_user(env
->gregs
[5], &((*grp
)[MC_G5
]));
2664 err
|= __put_user(env
->gregs
[6], &((*grp
)[MC_G6
]));
2665 err
|= __put_user(env
->gregs
[7], &((*grp
)[MC_G7
]));
2666 err
|= __put_user(env
->regwptr
[UREG_I0
], &((*grp
)[MC_O0
]));
2667 err
|= __put_user(env
->regwptr
[UREG_I1
], &((*grp
)[MC_O1
]));
2668 err
|= __put_user(env
->regwptr
[UREG_I2
], &((*grp
)[MC_O2
]));
2669 err
|= __put_user(env
->regwptr
[UREG_I3
], &((*grp
)[MC_O3
]));
2670 err
|= __put_user(env
->regwptr
[UREG_I4
], &((*grp
)[MC_O4
]));
2671 err
|= __put_user(env
->regwptr
[UREG_I5
], &((*grp
)[MC_O5
]));
2672 err
|= __put_user(env
->regwptr
[UREG_I6
], &((*grp
)[MC_O6
]));
2673 err
|= __put_user(env
->regwptr
[UREG_I7
], &((*grp
)[MC_O7
]));
2675 w_addr
= TARGET_STACK_BIAS
+env
->regwptr
[UREG_I6
];
2677 if (get_user(fp
, w_addr
+ offsetof(struct target_reg_window
, ins
[6]),
2680 if (get_user(i7
, w_addr
+ offsetof(struct target_reg_window
, ins
[7]),
2683 err
|= __put_user(fp
, &(mcp
->mc_fp
));
2684 err
|= __put_user(i7
, &(mcp
->mc_i7
));
2687 uint32_t *dst
= ucp
->tuc_mcontext
.mc_fpregs
.mcfpu_fregs
.sregs
;
2688 for (i
= 0; i
< 64; i
++, dst
++) {
2690 err
|= __put_user(env
->fpr
[i
/2].l
.lower
, dst
);
2692 err
|= __put_user(env
->fpr
[i
/2].l
.upper
, dst
);
2696 err
|= __put_user(env
->fsr
, &(mcp
->mc_fpregs
.mcfpu_fsr
));
2697 err
|= __put_user(env
->gsr
, &(mcp
->mc_fpregs
.mcfpu_gsr
));
2698 err
|= __put_user(env
->fprs
, &(mcp
->mc_fpregs
.mcfpu_fprs
));
2702 unlock_user_struct(ucp
, ucp_addr
, 1);
2705 unlock_user_struct(ucp
, ucp_addr
, 1);
2706 force_sig(TARGET_SIGSEGV
);
2709 #elif defined(TARGET_MIPS) || defined(TARGET_MIPS64)
2711 # if defined(TARGET_ABI_MIPSO32)
2712 struct target_sigcontext
{
2713 uint32_t sc_regmask
; /* Unused */
2716 uint64_t sc_regs
[32];
2717 uint64_t sc_fpregs
[32];
2718 uint32_t sc_ownedfp
; /* Unused */
2719 uint32_t sc_fpc_csr
;
2720 uint32_t sc_fpc_eir
; /* Unused */
2721 uint32_t sc_used_math
;
2722 uint32_t sc_dsp
; /* dsp status, was sc_ssflags */
2726 target_ulong sc_hi1
; /* Was sc_cause */
2727 target_ulong sc_lo1
; /* Was sc_badvaddr */
2728 target_ulong sc_hi2
; /* Was sc_sigset[4] */
2729 target_ulong sc_lo2
;
2730 target_ulong sc_hi3
;
2731 target_ulong sc_lo3
;
2733 # else /* N32 || N64 */
2734 struct target_sigcontext
{
2735 uint64_t sc_regs
[32];
2736 uint64_t sc_fpregs
[32];
2746 uint32_t sc_fpc_csr
;
2747 uint32_t sc_used_math
;
2749 uint32_t sc_reserved
;
2754 uint32_t sf_ass
[4]; /* argument save space for o32 */
2755 uint32_t sf_code
[2]; /* signal trampoline */
2756 struct target_sigcontext sf_sc
;
2757 target_sigset_t sf_mask
;
2760 struct target_ucontext
{
2761 target_ulong tuc_flags
;
2762 target_ulong tuc_link
;
2763 target_stack_t tuc_stack
;
2765 struct target_sigcontext tuc_mcontext
;
2766 target_sigset_t tuc_sigmask
;
2769 struct target_rt_sigframe
{
2770 uint32_t rs_ass
[4]; /* argument save space for o32 */
2771 uint32_t rs_code
[2]; /* signal trampoline */
2772 struct target_siginfo rs_info
;
2773 struct target_ucontext rs_uc
;
2776 /* Install trampoline to jump back from signal handler */
2777 static inline int install_sigtramp(unsigned int *tramp
, unsigned int syscall
)
2782 * Set up the return code ...
2784 * li v0, __NR__foo_sigreturn
2788 err
|= __put_user(0x24020000 + syscall
, tramp
+ 0);
2789 err
|= __put_user(0x0000000c , tramp
+ 1);
2794 setup_sigcontext(CPUMIPSState
*regs
, struct target_sigcontext
*sc
)
2799 err
|= __put_user(exception_resume_pc(regs
), &sc
->sc_pc
);
2800 regs
->hflags
&= ~MIPS_HFLAG_BMASK
;
2802 __put_user(0, &sc
->sc_regs
[0]);
2803 for (i
= 1; i
< 32; ++i
) {
2804 err
|= __put_user(regs
->active_tc
.gpr
[i
], &sc
->sc_regs
[i
]);
2807 err
|= __put_user(regs
->active_tc
.HI
[0], &sc
->sc_mdhi
);
2808 err
|= __put_user(regs
->active_tc
.LO
[0], &sc
->sc_mdlo
);
2810 /* Rather than checking for dsp existence, always copy. The storage
2811 would just be garbage otherwise. */
2812 err
|= __put_user(regs
->active_tc
.HI
[1], &sc
->sc_hi1
);
2813 err
|= __put_user(regs
->active_tc
.HI
[2], &sc
->sc_hi2
);
2814 err
|= __put_user(regs
->active_tc
.HI
[3], &sc
->sc_hi3
);
2815 err
|= __put_user(regs
->active_tc
.LO
[1], &sc
->sc_lo1
);
2816 err
|= __put_user(regs
->active_tc
.LO
[2], &sc
->sc_lo2
);
2817 err
|= __put_user(regs
->active_tc
.LO
[3], &sc
->sc_lo3
);
2819 uint32_t dsp
= cpu_rddsp(0x3ff, regs
);
2820 err
|= __put_user(dsp
, &sc
->sc_dsp
);
2823 err
|= __put_user(1, &sc
->sc_used_math
);
2825 for (i
= 0; i
< 32; ++i
) {
2826 err
|= __put_user(regs
->active_fpu
.fpr
[i
].d
, &sc
->sc_fpregs
[i
]);
2833 restore_sigcontext(CPUMIPSState
*regs
, struct target_sigcontext
*sc
)
2838 err
|= __get_user(regs
->CP0_EPC
, &sc
->sc_pc
);
2840 err
|= __get_user(regs
->active_tc
.HI
[0], &sc
->sc_mdhi
);
2841 err
|= __get_user(regs
->active_tc
.LO
[0], &sc
->sc_mdlo
);
2843 for (i
= 1; i
< 32; ++i
) {
2844 err
|= __get_user(regs
->active_tc
.gpr
[i
], &sc
->sc_regs
[i
]);
2847 err
|= __get_user(regs
->active_tc
.HI
[1], &sc
->sc_hi1
);
2848 err
|= __get_user(regs
->active_tc
.HI
[2], &sc
->sc_hi2
);
2849 err
|= __get_user(regs
->active_tc
.HI
[3], &sc
->sc_hi3
);
2850 err
|= __get_user(regs
->active_tc
.LO
[1], &sc
->sc_lo1
);
2851 err
|= __get_user(regs
->active_tc
.LO
[2], &sc
->sc_lo2
);
2852 err
|= __get_user(regs
->active_tc
.LO
[3], &sc
->sc_lo3
);
2855 err
|= __get_user(dsp
, &sc
->sc_dsp
);
2856 cpu_wrdsp(dsp
, 0x3ff, regs
);
2859 for (i
= 0; i
< 32; ++i
) {
2860 err
|= __get_user(regs
->active_fpu
.fpr
[i
].d
, &sc
->sc_fpregs
[i
]);
2867 * Determine which stack to use..
2869 static inline abi_ulong
2870 get_sigframe(struct target_sigaction
*ka
, CPUMIPSState
*regs
, size_t frame_size
)
2874 /* Default to using normal stack */
2875 sp
= regs
->active_tc
.gpr
[29];
2878 * FPU emulator may have its own trampoline active just
2879 * above the user stack, 16-bytes before the next lowest
2880 * 16 byte boundary. Try to avoid trashing it.
2884 /* This is the X/Open sanctioned signal stack switching. */
2885 if ((ka
->sa_flags
& TARGET_SA_ONSTACK
) && (sas_ss_flags (sp
) == 0)) {
2886 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
2889 return (sp
- frame_size
) & ~7;
2892 static void mips_set_hflags_isa_mode_from_pc(CPUMIPSState
*env
)
2894 if (env
->insn_flags
& (ASE_MIPS16
| ASE_MICROMIPS
)) {
2895 env
->hflags
&= ~MIPS_HFLAG_M16
;
2896 env
->hflags
|= (env
->active_tc
.PC
& 1) << MIPS_HFLAG_M16_SHIFT
;
2897 env
->active_tc
.PC
&= ~(target_ulong
) 1;
2901 # if defined(TARGET_ABI_MIPSO32)
2902 /* compare linux/arch/mips/kernel/signal.c:setup_frame() */
2903 static void setup_frame(int sig
, struct target_sigaction
* ka
,
2904 target_sigset_t
*set
, CPUMIPSState
*regs
)
2906 struct sigframe
*frame
;
2907 abi_ulong frame_addr
;
2910 frame_addr
= get_sigframe(ka
, regs
, sizeof(*frame
));
2911 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
2914 install_sigtramp(frame
->sf_code
, TARGET_NR_sigreturn
);
2916 if(setup_sigcontext(regs
, &frame
->sf_sc
))
2919 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
2920 if(__put_user(set
->sig
[i
], &frame
->sf_mask
.sig
[i
]))
2925 * Arguments to signal handler:
2927 * a0 = signal number
2928 * a1 = 0 (should be cause)
2929 * a2 = pointer to struct sigcontext
2931 * $25 and PC point to the signal handler, $29 points to the
2934 regs
->active_tc
.gpr
[ 4] = sig
;
2935 regs
->active_tc
.gpr
[ 5] = 0;
2936 regs
->active_tc
.gpr
[ 6] = frame_addr
+ offsetof(struct sigframe
, sf_sc
);
2937 regs
->active_tc
.gpr
[29] = frame_addr
;
2938 regs
->active_tc
.gpr
[31] = frame_addr
+ offsetof(struct sigframe
, sf_code
);
2939 /* The original kernel code sets CP0_EPC to the handler
2940 * since it returns to userland using eret
2941 * we cannot do this here, and we must set PC directly */
2942 regs
->active_tc
.PC
= regs
->active_tc
.gpr
[25] = ka
->_sa_handler
;
2943 mips_set_hflags_isa_mode_from_pc(regs
);
2944 unlock_user_struct(frame
, frame_addr
, 1);
2948 unlock_user_struct(frame
, frame_addr
, 1);
2949 force_sig(TARGET_SIGSEGV
/*, current*/);
2952 long do_sigreturn(CPUMIPSState
*regs
)
2954 struct sigframe
*frame
;
2955 abi_ulong frame_addr
;
2957 target_sigset_t target_set
;
2960 #if defined(DEBUG_SIGNAL)
2961 fprintf(stderr
, "do_sigreturn\n");
2963 frame_addr
= regs
->active_tc
.gpr
[29];
2964 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
2967 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
2968 if(__get_user(target_set
.sig
[i
], &frame
->sf_mask
.sig
[i
]))
2972 target_to_host_sigset_internal(&blocked
, &target_set
);
2973 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
2975 if (restore_sigcontext(regs
, &frame
->sf_sc
))
2980 * Don't let your children do this ...
2982 __asm__
__volatile__(
2990 regs
->active_tc
.PC
= regs
->CP0_EPC
;
2991 mips_set_hflags_isa_mode_from_pc(regs
);
2992 /* I am not sure this is right, but it seems to work
2993 * maybe a problem with nested signals ? */
2995 return -TARGET_QEMU_ESIGRETURN
;
2998 force_sig(TARGET_SIGSEGV
/*, current*/);
3003 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
3004 target_siginfo_t
*info
,
3005 target_sigset_t
*set
, CPUMIPSState
*env
)
3007 struct target_rt_sigframe
*frame
;
3008 abi_ulong frame_addr
;
3011 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
3012 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
3015 install_sigtramp(frame
->rs_code
, TARGET_NR_rt_sigreturn
);
3017 copy_siginfo_to_user(&frame
->rs_info
, info
);
3019 __put_user(0, &frame
->rs_uc
.tuc_flags
);
3020 __put_user(0, &frame
->rs_uc
.tuc_link
);
3021 __put_user(target_sigaltstack_used
.ss_sp
, &frame
->rs_uc
.tuc_stack
.ss_sp
);
3022 __put_user(target_sigaltstack_used
.ss_size
, &frame
->rs_uc
.tuc_stack
.ss_size
);
3023 __put_user(sas_ss_flags(get_sp_from_cpustate(env
)),
3024 &frame
->rs_uc
.tuc_stack
.ss_flags
);
3026 setup_sigcontext(env
, &frame
->rs_uc
.tuc_mcontext
);
3028 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
3029 __put_user(set
->sig
[i
], &frame
->rs_uc
.tuc_sigmask
.sig
[i
]);
3033 * Arguments to signal handler:
3035 * a0 = signal number
3036 * a1 = pointer to siginfo_t
3037 * a2 = pointer to struct ucontext
3039 * $25 and PC point to the signal handler, $29 points to the
3042 env
->active_tc
.gpr
[ 4] = sig
;
3043 env
->active_tc
.gpr
[ 5] = frame_addr
3044 + offsetof(struct target_rt_sigframe
, rs_info
);
3045 env
->active_tc
.gpr
[ 6] = frame_addr
3046 + offsetof(struct target_rt_sigframe
, rs_uc
);
3047 env
->active_tc
.gpr
[29] = frame_addr
;
3048 env
->active_tc
.gpr
[31] = frame_addr
3049 + offsetof(struct target_rt_sigframe
, rs_code
);
3050 /* The original kernel code sets CP0_EPC to the handler
3051 * since it returns to userland using eret
3052 * we cannot do this here, and we must set PC directly */
3053 env
->active_tc
.PC
= env
->active_tc
.gpr
[25] = ka
->_sa_handler
;
3054 mips_set_hflags_isa_mode_from_pc(env
);
3055 unlock_user_struct(frame
, frame_addr
, 1);
3059 unlock_user_struct(frame
, frame_addr
, 1);
3060 force_sig(TARGET_SIGSEGV
/*, current*/);
3063 long do_rt_sigreturn(CPUMIPSState
*env
)
3065 struct target_rt_sigframe
*frame
;
3066 abi_ulong frame_addr
;
3069 #if defined(DEBUG_SIGNAL)
3070 fprintf(stderr
, "do_rt_sigreturn\n");
3072 frame_addr
= env
->active_tc
.gpr
[29];
3073 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
3076 target_to_host_sigset(&blocked
, &frame
->rs_uc
.tuc_sigmask
);
3077 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
3079 if (restore_sigcontext(env
, &frame
->rs_uc
.tuc_mcontext
))
3082 if (do_sigaltstack(frame_addr
+
3083 offsetof(struct target_rt_sigframe
, rs_uc
.tuc_stack
),
3084 0, get_sp_from_cpustate(env
)) == -EFAULT
)
3087 env
->active_tc
.PC
= env
->CP0_EPC
;
3088 mips_set_hflags_isa_mode_from_pc(env
);
3089 /* I am not sure this is right, but it seems to work
3090 * maybe a problem with nested signals ? */
3092 return -TARGET_QEMU_ESIGRETURN
;
3095 force_sig(TARGET_SIGSEGV
/*, current*/);
3099 #elif defined(TARGET_SH4)
3102 * code and data structures from linux kernel:
3103 * include/asm-sh/sigcontext.h
3104 * arch/sh/kernel/signal.c
3107 struct target_sigcontext
{
3108 target_ulong oldmask
;
3111 target_ulong sc_gregs
[16];
3115 target_ulong sc_gbr
;
3116 target_ulong sc_mach
;
3117 target_ulong sc_macl
;
3120 target_ulong sc_fpregs
[16];
3121 target_ulong sc_xfpregs
[16];
3122 unsigned int sc_fpscr
;
3123 unsigned int sc_fpul
;
3124 unsigned int sc_ownedfp
;
3127 struct target_sigframe
3129 struct target_sigcontext sc
;
3130 target_ulong extramask
[TARGET_NSIG_WORDS
-1];
3131 uint16_t retcode
[3];
3135 struct target_ucontext
{
3136 target_ulong tuc_flags
;
3137 struct target_ucontext
*tuc_link
;
3138 target_stack_t tuc_stack
;
3139 struct target_sigcontext tuc_mcontext
;
3140 target_sigset_t tuc_sigmask
; /* mask last for extensibility */
3143 struct target_rt_sigframe
3145 struct target_siginfo info
;
3146 struct target_ucontext uc
;
3147 uint16_t retcode
[3];
3151 #define MOVW(n) (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */
3152 #define TRAP_NOARG 0xc310 /* Syscall w/no args (NR in R3) SH3/4 */
3154 static abi_ulong
get_sigframe(struct target_sigaction
*ka
,
3155 unsigned long sp
, size_t frame_size
)
3157 if ((ka
->sa_flags
& TARGET_SA_ONSTACK
) && (sas_ss_flags(sp
) == 0)) {
3158 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
3161 return (sp
- frame_size
) & -8ul;
3164 static int setup_sigcontext(struct target_sigcontext
*sc
,
3165 CPUSH4State
*regs
, unsigned long mask
)
3170 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
3171 COPY(gregs
[0]); COPY(gregs
[1]);
3172 COPY(gregs
[2]); COPY(gregs
[3]);
3173 COPY(gregs
[4]); COPY(gregs
[5]);
3174 COPY(gregs
[6]); COPY(gregs
[7]);
3175 COPY(gregs
[8]); COPY(gregs
[9]);
3176 COPY(gregs
[10]); COPY(gregs
[11]);
3177 COPY(gregs
[12]); COPY(gregs
[13]);
3178 COPY(gregs
[14]); COPY(gregs
[15]);
3179 COPY(gbr
); COPY(mach
);
3180 COPY(macl
); COPY(pr
);
3184 for (i
=0; i
<16; i
++) {
3185 err
|= __put_user(regs
->fregs
[i
], &sc
->sc_fpregs
[i
]);
3187 err
|= __put_user(regs
->fpscr
, &sc
->sc_fpscr
);
3188 err
|= __put_user(regs
->fpul
, &sc
->sc_fpul
);
3190 /* non-iBCS2 extensions.. */
3191 err
|= __put_user(mask
, &sc
->oldmask
);
3196 static int restore_sigcontext(CPUSH4State
*regs
, struct target_sigcontext
*sc
,
3199 unsigned int err
= 0;
3202 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
3204 COPY(gregs
[2]); COPY(gregs
[3]);
3205 COPY(gregs
[4]); COPY(gregs
[5]);
3206 COPY(gregs
[6]); COPY(gregs
[7]);
3207 COPY(gregs
[8]); COPY(gregs
[9]);
3208 COPY(gregs
[10]); COPY(gregs
[11]);
3209 COPY(gregs
[12]); COPY(gregs
[13]);
3210 COPY(gregs
[14]); COPY(gregs
[15]);
3211 COPY(gbr
); COPY(mach
);
3212 COPY(macl
); COPY(pr
);
3216 for (i
=0; i
<16; i
++) {
3217 err
|= __get_user(regs
->fregs
[i
], &sc
->sc_fpregs
[i
]);
3219 err
|= __get_user(regs
->fpscr
, &sc
->sc_fpscr
);
3220 err
|= __get_user(regs
->fpul
, &sc
->sc_fpul
);
3222 regs
->tra
= -1; /* disable syscall checks */
3223 err
|= __get_user(*r0_p
, &sc
->sc_gregs
[0]);
3227 static void setup_frame(int sig
, struct target_sigaction
*ka
,
3228 target_sigset_t
*set
, CPUSH4State
*regs
)
3230 struct target_sigframe
*frame
;
3231 abi_ulong frame_addr
;
3236 frame_addr
= get_sigframe(ka
, regs
->gregs
[15], sizeof(*frame
));
3237 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
3240 signal
= current_exec_domain_sig(sig
);
3242 err
|= setup_sigcontext(&frame
->sc
, regs
, set
->sig
[0]);
3244 for (i
= 0; i
< TARGET_NSIG_WORDS
- 1; i
++) {
3245 err
|= __put_user(set
->sig
[i
+ 1], &frame
->extramask
[i
]);
3248 /* Set up to return from userspace. If provided, use a stub
3249 already in userspace. */
3250 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
3251 regs
->pr
= (unsigned long) ka
->sa_restorer
;
3253 /* Generate return code (system call to sigreturn) */
3254 err
|= __put_user(MOVW(2), &frame
->retcode
[0]);
3255 err
|= __put_user(TRAP_NOARG
, &frame
->retcode
[1]);
3256 err
|= __put_user((TARGET_NR_sigreturn
), &frame
->retcode
[2]);
3257 regs
->pr
= (unsigned long) frame
->retcode
;
3263 /* Set up registers for signal handler */
3264 regs
->gregs
[15] = frame_addr
;
3265 regs
->gregs
[4] = signal
; /* Arg for signal handler */
3267 regs
->gregs
[6] = frame_addr
+= offsetof(typeof(*frame
), sc
);
3268 regs
->pc
= (unsigned long) ka
->_sa_handler
;
3270 unlock_user_struct(frame
, frame_addr
, 1);
3274 unlock_user_struct(frame
, frame_addr
, 1);
3275 force_sig(TARGET_SIGSEGV
);
3278 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
3279 target_siginfo_t
*info
,
3280 target_sigset_t
*set
, CPUSH4State
*regs
)
3282 struct target_rt_sigframe
*frame
;
3283 abi_ulong frame_addr
;
3288 frame_addr
= get_sigframe(ka
, regs
->gregs
[15], sizeof(*frame
));
3289 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
3292 signal
= current_exec_domain_sig(sig
);
3294 err
|= copy_siginfo_to_user(&frame
->info
, info
);
3296 /* Create the ucontext. */
3297 err
|= __put_user(0, &frame
->uc
.tuc_flags
);
3298 err
|= __put_user(0, (unsigned long *)&frame
->uc
.tuc_link
);
3299 err
|= __put_user((unsigned long)target_sigaltstack_used
.ss_sp
,
3300 &frame
->uc
.tuc_stack
.ss_sp
);
3301 err
|= __put_user(sas_ss_flags(regs
->gregs
[15]),
3302 &frame
->uc
.tuc_stack
.ss_flags
);
3303 err
|= __put_user(target_sigaltstack_used
.ss_size
,
3304 &frame
->uc
.tuc_stack
.ss_size
);
3305 err
|= setup_sigcontext(&frame
->uc
.tuc_mcontext
,
3307 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
3308 err
|= __put_user(set
->sig
[i
], &frame
->uc
.tuc_sigmask
.sig
[i
]);
3311 /* Set up to return from userspace. If provided, use a stub
3312 already in userspace. */
3313 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
3314 regs
->pr
= (unsigned long) ka
->sa_restorer
;
3316 /* Generate return code (system call to sigreturn) */
3317 err
|= __put_user(MOVW(2), &frame
->retcode
[0]);
3318 err
|= __put_user(TRAP_NOARG
, &frame
->retcode
[1]);
3319 err
|= __put_user((TARGET_NR_rt_sigreturn
), &frame
->retcode
[2]);
3320 regs
->pr
= (unsigned long) frame
->retcode
;
3326 /* Set up registers for signal handler */
3327 regs
->gregs
[15] = frame_addr
;
3328 regs
->gregs
[4] = signal
; /* Arg for signal handler */
3329 regs
->gregs
[5] = frame_addr
+ offsetof(typeof(*frame
), info
);
3330 regs
->gregs
[6] = frame_addr
+ offsetof(typeof(*frame
), uc
);
3331 regs
->pc
= (unsigned long) ka
->_sa_handler
;
3333 unlock_user_struct(frame
, frame_addr
, 1);
3337 unlock_user_struct(frame
, frame_addr
, 1);
3338 force_sig(TARGET_SIGSEGV
);
3341 long do_sigreturn(CPUSH4State
*regs
)
3343 struct target_sigframe
*frame
;
3344 abi_ulong frame_addr
;
3346 target_sigset_t target_set
;
3351 #if defined(DEBUG_SIGNAL)
3352 fprintf(stderr
, "do_sigreturn\n");
3354 frame_addr
= regs
->gregs
[15];
3355 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
3358 err
|= __get_user(target_set
.sig
[0], &frame
->sc
.oldmask
);
3359 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
3360 err
|= (__get_user(target_set
.sig
[i
], &frame
->extramask
[i
- 1]));
3366 target_to_host_sigset_internal(&blocked
, &target_set
);
3367 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
3369 if (restore_sigcontext(regs
, &frame
->sc
, &r0
))
3372 unlock_user_struct(frame
, frame_addr
, 0);
3376 unlock_user_struct(frame
, frame_addr
, 0);
3377 force_sig(TARGET_SIGSEGV
);
3381 long do_rt_sigreturn(CPUSH4State
*regs
)
3383 struct target_rt_sigframe
*frame
;
3384 abi_ulong frame_addr
;
3388 #if defined(DEBUG_SIGNAL)
3389 fprintf(stderr
, "do_rt_sigreturn\n");
3391 frame_addr
= regs
->gregs
[15];
3392 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
3395 target_to_host_sigset(&blocked
, &frame
->uc
.tuc_sigmask
);
3396 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
3398 if (restore_sigcontext(regs
, &frame
->uc
.tuc_mcontext
, &r0
))
3401 if (do_sigaltstack(frame_addr
+
3402 offsetof(struct target_rt_sigframe
, uc
.tuc_stack
),
3403 0, get_sp_from_cpustate(regs
)) == -EFAULT
)
3406 unlock_user_struct(frame
, frame_addr
, 0);
3410 unlock_user_struct(frame
, frame_addr
, 0);
3411 force_sig(TARGET_SIGSEGV
);
3414 #elif defined(TARGET_MICROBLAZE)
3416 struct target_sigcontext
{
3417 struct target_pt_regs regs
; /* needs to be first */
3421 struct target_stack_t
{
3424 unsigned int ss_size
;
3427 struct target_ucontext
{
3428 abi_ulong tuc_flags
;
3430 struct target_stack_t tuc_stack
;
3431 struct target_sigcontext tuc_mcontext
;
3432 uint32_t tuc_extramask
[TARGET_NSIG_WORDS
- 1];
3435 /* Signal frames. */
3436 struct target_signal_frame
{
3437 struct target_ucontext uc
;
3438 uint32_t extramask
[TARGET_NSIG_WORDS
- 1];
3442 struct rt_signal_frame
{
3448 static void setup_sigcontext(struct target_sigcontext
*sc
, CPUMBState
*env
)
3450 __put_user(env
->regs
[0], &sc
->regs
.r0
);
3451 __put_user(env
->regs
[1], &sc
->regs
.r1
);
3452 __put_user(env
->regs
[2], &sc
->regs
.r2
);
3453 __put_user(env
->regs
[3], &sc
->regs
.r3
);
3454 __put_user(env
->regs
[4], &sc
->regs
.r4
);
3455 __put_user(env
->regs
[5], &sc
->regs
.r5
);
3456 __put_user(env
->regs
[6], &sc
->regs
.r6
);
3457 __put_user(env
->regs
[7], &sc
->regs
.r7
);
3458 __put_user(env
->regs
[8], &sc
->regs
.r8
);
3459 __put_user(env
->regs
[9], &sc
->regs
.r9
);
3460 __put_user(env
->regs
[10], &sc
->regs
.r10
);
3461 __put_user(env
->regs
[11], &sc
->regs
.r11
);
3462 __put_user(env
->regs
[12], &sc
->regs
.r12
);
3463 __put_user(env
->regs
[13], &sc
->regs
.r13
);
3464 __put_user(env
->regs
[14], &sc
->regs
.r14
);
3465 __put_user(env
->regs
[15], &sc
->regs
.r15
);
3466 __put_user(env
->regs
[16], &sc
->regs
.r16
);
3467 __put_user(env
->regs
[17], &sc
->regs
.r17
);
3468 __put_user(env
->regs
[18], &sc
->regs
.r18
);
3469 __put_user(env
->regs
[19], &sc
->regs
.r19
);
3470 __put_user(env
->regs
[20], &sc
->regs
.r20
);
3471 __put_user(env
->regs
[21], &sc
->regs
.r21
);
3472 __put_user(env
->regs
[22], &sc
->regs
.r22
);
3473 __put_user(env
->regs
[23], &sc
->regs
.r23
);
3474 __put_user(env
->regs
[24], &sc
->regs
.r24
);
3475 __put_user(env
->regs
[25], &sc
->regs
.r25
);
3476 __put_user(env
->regs
[26], &sc
->regs
.r26
);
3477 __put_user(env
->regs
[27], &sc
->regs
.r27
);
3478 __put_user(env
->regs
[28], &sc
->regs
.r28
);
3479 __put_user(env
->regs
[29], &sc
->regs
.r29
);
3480 __put_user(env
->regs
[30], &sc
->regs
.r30
);
3481 __put_user(env
->regs
[31], &sc
->regs
.r31
);
3482 __put_user(env
->sregs
[SR_PC
], &sc
->regs
.pc
);
3485 static void restore_sigcontext(struct target_sigcontext
*sc
, CPUMBState
*env
)
3487 __get_user(env
->regs
[0], &sc
->regs
.r0
);
3488 __get_user(env
->regs
[1], &sc
->regs
.r1
);
3489 __get_user(env
->regs
[2], &sc
->regs
.r2
);
3490 __get_user(env
->regs
[3], &sc
->regs
.r3
);
3491 __get_user(env
->regs
[4], &sc
->regs
.r4
);
3492 __get_user(env
->regs
[5], &sc
->regs
.r5
);
3493 __get_user(env
->regs
[6], &sc
->regs
.r6
);
3494 __get_user(env
->regs
[7], &sc
->regs
.r7
);
3495 __get_user(env
->regs
[8], &sc
->regs
.r8
);
3496 __get_user(env
->regs
[9], &sc
->regs
.r9
);
3497 __get_user(env
->regs
[10], &sc
->regs
.r10
);
3498 __get_user(env
->regs
[11], &sc
->regs
.r11
);
3499 __get_user(env
->regs
[12], &sc
->regs
.r12
);
3500 __get_user(env
->regs
[13], &sc
->regs
.r13
);
3501 __get_user(env
->regs
[14], &sc
->regs
.r14
);
3502 __get_user(env
->regs
[15], &sc
->regs
.r15
);
3503 __get_user(env
->regs
[16], &sc
->regs
.r16
);
3504 __get_user(env
->regs
[17], &sc
->regs
.r17
);
3505 __get_user(env
->regs
[18], &sc
->regs
.r18
);
3506 __get_user(env
->regs
[19], &sc
->regs
.r19
);
3507 __get_user(env
->regs
[20], &sc
->regs
.r20
);
3508 __get_user(env
->regs
[21], &sc
->regs
.r21
);
3509 __get_user(env
->regs
[22], &sc
->regs
.r22
);
3510 __get_user(env
->regs
[23], &sc
->regs
.r23
);
3511 __get_user(env
->regs
[24], &sc
->regs
.r24
);
3512 __get_user(env
->regs
[25], &sc
->regs
.r25
);
3513 __get_user(env
->regs
[26], &sc
->regs
.r26
);
3514 __get_user(env
->regs
[27], &sc
->regs
.r27
);
3515 __get_user(env
->regs
[28], &sc
->regs
.r28
);
3516 __get_user(env
->regs
[29], &sc
->regs
.r29
);
3517 __get_user(env
->regs
[30], &sc
->regs
.r30
);
3518 __get_user(env
->regs
[31], &sc
->regs
.r31
);
3519 __get_user(env
->sregs
[SR_PC
], &sc
->regs
.pc
);
3522 static abi_ulong
get_sigframe(struct target_sigaction
*ka
,
3523 CPUMBState
*env
, int frame_size
)
3525 abi_ulong sp
= env
->regs
[1];
3527 if ((ka
->sa_flags
& SA_ONSTACK
) != 0 && !on_sig_stack(sp
))
3528 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
3530 return ((sp
- frame_size
) & -8UL);
3533 static void setup_frame(int sig
, struct target_sigaction
*ka
,
3534 target_sigset_t
*set
, CPUMBState
*env
)
3536 struct target_signal_frame
*frame
;
3537 abi_ulong frame_addr
;
3541 frame_addr
= get_sigframe(ka
, env
, sizeof *frame
);
3542 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
3545 /* Save the mask. */
3546 err
|= __put_user(set
->sig
[0], &frame
->uc
.tuc_mcontext
.oldmask
);
3550 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
3551 if (__put_user(set
->sig
[i
], &frame
->extramask
[i
- 1]))
3555 setup_sigcontext(&frame
->uc
.tuc_mcontext
, env
);
3557 /* Set up to return from userspace. If provided, use a stub
3558 already in userspace. */
3559 /* minus 8 is offset to cater for "rtsd r15,8" offset */
3560 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
3561 env
->regs
[15] = ((unsigned long)ka
->sa_restorer
)-8;
3564 /* Note, these encodings are _big endian_! */
3565 /* addi r12, r0, __NR_sigreturn */
3566 t
= 0x31800000UL
| TARGET_NR_sigreturn
;
3567 err
|= __put_user(t
, frame
->tramp
+ 0);
3570 err
|= __put_user(t
, frame
->tramp
+ 1);
3572 /* Return from sighandler will jump to the tramp.
3573 Negative 8 offset because return is rtsd r15, 8 */
3574 env
->regs
[15] = ((unsigned long)frame
->tramp
) - 8;
3580 /* Set up registers for signal handler */
3581 env
->regs
[1] = frame_addr
;
3582 /* Signal handler args: */
3583 env
->regs
[5] = sig
; /* Arg 0: signum */
3585 /* arg 1: sigcontext */
3586 env
->regs
[7] = frame_addr
+= offsetof(typeof(*frame
), uc
);
3588 /* Offset of 4 to handle microblaze rtid r14, 0 */
3589 env
->sregs
[SR_PC
] = (unsigned long)ka
->_sa_handler
;
3591 unlock_user_struct(frame
, frame_addr
, 1);
3594 unlock_user_struct(frame
, frame_addr
, 1);
3595 force_sig(TARGET_SIGSEGV
);
3598 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
3599 target_siginfo_t
*info
,
3600 target_sigset_t
*set
, CPUMBState
*env
)
3602 fprintf(stderr
, "Microblaze setup_rt_frame: not implemented\n");
3605 long do_sigreturn(CPUMBState
*env
)
3607 struct target_signal_frame
*frame
;
3608 abi_ulong frame_addr
;
3609 target_sigset_t target_set
;
3613 frame_addr
= env
->regs
[R_SP
];
3614 /* Make sure the guest isn't playing games. */
3615 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 1))
3618 /* Restore blocked signals */
3619 if (__get_user(target_set
.sig
[0], &frame
->uc
.tuc_mcontext
.oldmask
))
3621 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
3622 if (__get_user(target_set
.sig
[i
], &frame
->extramask
[i
- 1]))
3625 target_to_host_sigset_internal(&set
, &target_set
);
3626 sigprocmask(SIG_SETMASK
, &set
, NULL
);
3628 restore_sigcontext(&frame
->uc
.tuc_mcontext
, env
);
3629 /* We got here through a sigreturn syscall, our path back is via an
3630 rtb insn so setup r14 for that. */
3631 env
->regs
[14] = env
->sregs
[SR_PC
];
3633 unlock_user_struct(frame
, frame_addr
, 0);
3634 return env
->regs
[10];
3636 unlock_user_struct(frame
, frame_addr
, 0);
3637 force_sig(TARGET_SIGSEGV
);
3640 long do_rt_sigreturn(CPUMBState
*env
)
3642 fprintf(stderr
, "Microblaze do_rt_sigreturn: not implemented\n");
3643 return -TARGET_ENOSYS
;
3646 #elif defined(TARGET_CRIS)
3648 struct target_sigcontext
{
3649 struct target_pt_regs regs
; /* needs to be first */
3651 uint32_t usp
; /* usp before stacking this gunk on it */
3654 /* Signal frames. */
3655 struct target_signal_frame
{
3656 struct target_sigcontext sc
;
3657 uint32_t extramask
[TARGET_NSIG_WORDS
- 1];
3658 uint8_t retcode
[8]; /* Trampoline code. */
3661 struct rt_signal_frame
{
3666 uint8_t retcode
[8]; /* Trampoline code. */
3669 static void setup_sigcontext(struct target_sigcontext
*sc
, CPUCRISState
*env
)
3671 __put_user(env
->regs
[0], &sc
->regs
.r0
);
3672 __put_user(env
->regs
[1], &sc
->regs
.r1
);
3673 __put_user(env
->regs
[2], &sc
->regs
.r2
);
3674 __put_user(env
->regs
[3], &sc
->regs
.r3
);
3675 __put_user(env
->regs
[4], &sc
->regs
.r4
);
3676 __put_user(env
->regs
[5], &sc
->regs
.r5
);
3677 __put_user(env
->regs
[6], &sc
->regs
.r6
);
3678 __put_user(env
->regs
[7], &sc
->regs
.r7
);
3679 __put_user(env
->regs
[8], &sc
->regs
.r8
);
3680 __put_user(env
->regs
[9], &sc
->regs
.r9
);
3681 __put_user(env
->regs
[10], &sc
->regs
.r10
);
3682 __put_user(env
->regs
[11], &sc
->regs
.r11
);
3683 __put_user(env
->regs
[12], &sc
->regs
.r12
);
3684 __put_user(env
->regs
[13], &sc
->regs
.r13
);
3685 __put_user(env
->regs
[14], &sc
->usp
);
3686 __put_user(env
->regs
[15], &sc
->regs
.acr
);
3687 __put_user(env
->pregs
[PR_MOF
], &sc
->regs
.mof
);
3688 __put_user(env
->pregs
[PR_SRP
], &sc
->regs
.srp
);
3689 __put_user(env
->pc
, &sc
->regs
.erp
);
3692 static void restore_sigcontext(struct target_sigcontext
*sc
, CPUCRISState
*env
)
3694 __get_user(env
->regs
[0], &sc
->regs
.r0
);
3695 __get_user(env
->regs
[1], &sc
->regs
.r1
);
3696 __get_user(env
->regs
[2], &sc
->regs
.r2
);
3697 __get_user(env
->regs
[3], &sc
->regs
.r3
);
3698 __get_user(env
->regs
[4], &sc
->regs
.r4
);
3699 __get_user(env
->regs
[5], &sc
->regs
.r5
);
3700 __get_user(env
->regs
[6], &sc
->regs
.r6
);
3701 __get_user(env
->regs
[7], &sc
->regs
.r7
);
3702 __get_user(env
->regs
[8], &sc
->regs
.r8
);
3703 __get_user(env
->regs
[9], &sc
->regs
.r9
);
3704 __get_user(env
->regs
[10], &sc
->regs
.r10
);
3705 __get_user(env
->regs
[11], &sc
->regs
.r11
);
3706 __get_user(env
->regs
[12], &sc
->regs
.r12
);
3707 __get_user(env
->regs
[13], &sc
->regs
.r13
);
3708 __get_user(env
->regs
[14], &sc
->usp
);
3709 __get_user(env
->regs
[15], &sc
->regs
.acr
);
3710 __get_user(env
->pregs
[PR_MOF
], &sc
->regs
.mof
);
3711 __get_user(env
->pregs
[PR_SRP
], &sc
->regs
.srp
);
3712 __get_user(env
->pc
, &sc
->regs
.erp
);
3715 static abi_ulong
get_sigframe(CPUCRISState
*env
, int framesize
)
3718 /* Align the stack downwards to 4. */
3719 sp
= (env
->regs
[R_SP
] & ~3);
3720 return sp
- framesize
;
3723 static void setup_frame(int sig
, struct target_sigaction
*ka
,
3724 target_sigset_t
*set
, CPUCRISState
*env
)
3726 struct target_signal_frame
*frame
;
3727 abi_ulong frame_addr
;
3731 frame_addr
= get_sigframe(env
, sizeof *frame
);
3732 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
3736 * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't
3737 * use this trampoline anymore but it sets it up for GDB.
3738 * In QEMU, using the trampoline simplifies things a bit so we use it.
3740 * This is movu.w __NR_sigreturn, r9; break 13;
3742 err
|= __put_user(0x9c5f, frame
->retcode
+0);
3743 err
|= __put_user(TARGET_NR_sigreturn
,
3745 err
|= __put_user(0xe93d, frame
->retcode
+4);
3747 /* Save the mask. */
3748 err
|= __put_user(set
->sig
[0], &frame
->sc
.oldmask
);
3752 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
3753 if (__put_user(set
->sig
[i
], &frame
->extramask
[i
- 1]))
3757 setup_sigcontext(&frame
->sc
, env
);
3759 /* Move the stack and setup the arguments for the handler. */
3760 env
->regs
[R_SP
] = frame_addr
;
3761 env
->regs
[10] = sig
;
3762 env
->pc
= (unsigned long) ka
->_sa_handler
;
3763 /* Link SRP so the guest returns through the trampoline. */
3764 env
->pregs
[PR_SRP
] = frame_addr
+ offsetof(typeof(*frame
), retcode
);
3766 unlock_user_struct(frame
, frame_addr
, 1);
3769 unlock_user_struct(frame
, frame_addr
, 1);
3770 force_sig(TARGET_SIGSEGV
);
3773 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
3774 target_siginfo_t
*info
,
3775 target_sigset_t
*set
, CPUCRISState
*env
)
3777 fprintf(stderr
, "CRIS setup_rt_frame: not implemented\n");
3780 long do_sigreturn(CPUCRISState
*env
)
3782 struct target_signal_frame
*frame
;
3783 abi_ulong frame_addr
;
3784 target_sigset_t target_set
;
3788 frame_addr
= env
->regs
[R_SP
];
3789 /* Make sure the guest isn't playing games. */
3790 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 1))
3793 /* Restore blocked signals */
3794 if (__get_user(target_set
.sig
[0], &frame
->sc
.oldmask
))
3796 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
3797 if (__get_user(target_set
.sig
[i
], &frame
->extramask
[i
- 1]))
3800 target_to_host_sigset_internal(&set
, &target_set
);
3801 sigprocmask(SIG_SETMASK
, &set
, NULL
);
3803 restore_sigcontext(&frame
->sc
, env
);
3804 unlock_user_struct(frame
, frame_addr
, 0);
3805 return env
->regs
[10];
3807 unlock_user_struct(frame
, frame_addr
, 0);
3808 force_sig(TARGET_SIGSEGV
);
3811 long do_rt_sigreturn(CPUCRISState
*env
)
3813 fprintf(stderr
, "CRIS do_rt_sigreturn: not implemented\n");
3814 return -TARGET_ENOSYS
;
3817 #elif defined(TARGET_OPENRISC)
3819 struct target_sigcontext
{
3820 struct target_pt_regs regs
;
3825 struct target_ucontext
{
3826 abi_ulong tuc_flags
;
3828 target_stack_t tuc_stack
;
3829 struct target_sigcontext tuc_mcontext
;
3830 target_sigset_t tuc_sigmask
; /* mask last for extensibility */
3833 struct target_rt_sigframe
{
3836 struct target_siginfo info
;
3837 struct target_sigcontext sc
;
3838 struct target_ucontext uc
;
3839 unsigned char retcode
[16]; /* trampoline code */
3842 /* This is the asm-generic/ucontext.h version */
3844 static int restore_sigcontext(CPUOpenRISCState
*regs
,
3845 struct target_sigcontext
*sc
)
3847 unsigned int err
= 0;
3848 unsigned long old_usp
;
3850 /* Alwys make any pending restarted system call return -EINTR */
3851 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
3853 /* restore the regs from &sc->regs (same as sc, since regs is first)
3854 * (sc is already checked for VERIFY_READ since the sigframe was
3855 * checked in sys_sigreturn previously)
3858 if (copy_from_user(regs
, &sc
, sizeof(struct target_pt_regs
))) {
3862 /* make sure the U-flag is set so user-mode cannot fool us */
3866 /* restore the old USP as it was before we stacked the sc etc.
3867 * (we cannot just pop the sigcontext since we aligned the sp and
3868 * stuff after pushing it)
3871 err
|= __get_user(old_usp
, &sc
->usp
);
3872 phx_signal("old_usp 0x%lx", old_usp
);
3874 __PHX__ REALLY
/* ??? */
3876 regs
->gpr
[1] = old_usp
;
3878 /* TODO: the other ports use regs->orig_XX to disable syscall checks
3879 * after this completes, but we don't use that mechanism. maybe we can
3890 /* Set up a signal frame. */
3892 static int setup_sigcontext(struct target_sigcontext
*sc
,
3893 CPUOpenRISCState
*regs
,
3897 unsigned long usp
= regs
->gpr
[1];
3899 /* copy the regs. they are first in sc so we can use sc directly */
3901 /*err |= copy_to_user(&sc, regs, sizeof(struct target_pt_regs));*/
3903 /* Set the frametype to CRIS_FRAME_NORMAL for the execution of
3904 the signal handler. The frametype will be restored to its previous
3905 value in restore_sigcontext. */
3906 /*regs->frametype = CRIS_FRAME_NORMAL;*/
3908 /* then some other stuff */
3909 err
|= __put_user(mask
, &sc
->oldmask
);
3910 err
|= __put_user(usp
, &sc
->usp
); return err
;
3913 static inline unsigned long align_sigframe(unsigned long sp
)
3920 static inline abi_ulong
get_sigframe(struct target_sigaction
*ka
,
3921 CPUOpenRISCState
*regs
,
3924 unsigned long sp
= regs
->gpr
[1];
3925 int onsigstack
= on_sig_stack(sp
);
3928 /* This is the X/Open sanctioned signal stack switching. */
3929 if ((ka
->sa_flags
& SA_ONSTACK
) != 0 && !onsigstack
) {
3930 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
3933 sp
= align_sigframe(sp
- frame_size
);
3936 * If we are on the alternate signal stack and would overflow it, don't.
3937 * Return an always-bogus address instead so we will die with SIGSEGV.
3940 if (onsigstack
&& !likely(on_sig_stack(sp
))) {
3947 static void setup_frame(int sig
, struct target_sigaction
*ka
,
3948 target_sigset_t
*set
, CPUOpenRISCState
*env
)
3950 qemu_log("Not implement.\n");
3953 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
3954 target_siginfo_t
*info
,
3955 target_sigset_t
*set
, CPUOpenRISCState
*env
)
3958 abi_ulong frame_addr
;
3959 unsigned long return_ip
;
3960 struct target_rt_sigframe
*frame
;
3961 abi_ulong info_addr
, uc_addr
;
3963 frame_addr
= get_sigframe(ka
, env
, sizeof *frame
);
3965 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
3966 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0)) {
3970 info_addr
= frame_addr
+ offsetof(struct target_rt_sigframe
, info
);
3971 err
|= __put_user(info_addr
, &frame
->pinfo
);
3972 uc_addr
= frame_addr
+ offsetof(struct target_rt_sigframe
, uc
);
3973 err
|= __put_user(uc_addr
, &frame
->puc
);
3975 if (ka
->sa_flags
& SA_SIGINFO
) {
3976 err
|= copy_siginfo_to_user(&frame
->info
, info
);
3982 /*err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));*/
3983 err
|= __put_user(0, &frame
->uc
.tuc_flags
);
3984 err
|= __put_user(0, &frame
->uc
.tuc_link
);
3985 err
|= __put_user(target_sigaltstack_used
.ss_sp
,
3986 &frame
->uc
.tuc_stack
.ss_sp
);
3987 err
|= __put_user(sas_ss_flags(env
->gpr
[1]), &frame
->uc
.tuc_stack
.ss_flags
);
3988 err
|= __put_user(target_sigaltstack_used
.ss_size
,
3989 &frame
->uc
.tuc_stack
.ss_size
);
3990 err
|= setup_sigcontext(&frame
->sc
, env
, set
->sig
[0]);
3992 /*err |= copy_to_user(frame->uc.tuc_sigmask, set, sizeof(*set));*/
3998 /* trampoline - the desired return ip is the retcode itself */
3999 return_ip
= (unsigned long)&frame
->retcode
;
4000 /* This is l.ori r11,r0,__NR_sigreturn, l.sys 1 */
4001 err
|= __put_user(0xa960, (short *)(frame
->retcode
+ 0));
4002 err
|= __put_user(TARGET_NR_rt_sigreturn
, (short *)(frame
->retcode
+ 2));
4003 err
|= __put_user(0x20000001, (unsigned long *)(frame
->retcode
+ 4));
4004 err
|= __put_user(0x15000000, (unsigned long *)(frame
->retcode
+ 8));
4010 /* TODO what is the current->exec_domain stuff and invmap ? */
4012 /* Set up registers for signal handler */
4013 env
->pc
= (unsigned long)ka
->_sa_handler
; /* what we enter NOW */
4014 env
->gpr
[9] = (unsigned long)return_ip
; /* what we enter LATER */
4015 env
->gpr
[3] = (unsigned long)sig
; /* arg 1: signo */
4016 env
->gpr
[4] = (unsigned long)&frame
->info
; /* arg 2: (siginfo_t*) */
4017 env
->gpr
[5] = (unsigned long)&frame
->uc
; /* arg 3: ucontext */
4019 /* actually move the usp to reflect the stacked frame */
4020 env
->gpr
[1] = (unsigned long)frame
;
4025 unlock_user_struct(frame
, frame_addr
, 1);
4026 if (sig
== TARGET_SIGSEGV
) {
4027 ka
->_sa_handler
= TARGET_SIG_DFL
;
4029 force_sig(TARGET_SIGSEGV
);
4032 long do_sigreturn(CPUOpenRISCState
*env
)
4035 qemu_log("do_sigreturn: not implemented\n");
4036 return -TARGET_ENOSYS
;
4039 long do_rt_sigreturn(CPUOpenRISCState
*env
)
4041 qemu_log("do_rt_sigreturn: not implemented\n");
4042 return -TARGET_ENOSYS
;
4044 /* TARGET_OPENRISC */
4046 #elif defined(TARGET_S390X)
4048 #define __NUM_GPRS 16
4049 #define __NUM_FPRS 16
4050 #define __NUM_ACRS 16
4052 #define S390_SYSCALL_SIZE 2
4053 #define __SIGNAL_FRAMESIZE 160 /* FIXME: 31-bit mode -> 96 */
4055 #define _SIGCONTEXT_NSIG 64
4056 #define _SIGCONTEXT_NSIG_BPW 64 /* FIXME: 31-bit mode -> 32 */
4057 #define _SIGCONTEXT_NSIG_WORDS (_SIGCONTEXT_NSIG / _SIGCONTEXT_NSIG_BPW)
4058 #define _SIGMASK_COPY_SIZE (sizeof(unsigned long)*_SIGCONTEXT_NSIG_WORDS)
4059 #define PSW_ADDR_AMODE 0x0000000000000000UL /* 0x80000000UL for 31-bit */
4060 #define S390_SYSCALL_OPCODE ((uint16_t)0x0a00)
4064 target_ulong gprs
[__NUM_GPRS
];
4065 unsigned int acrs
[__NUM_ACRS
];
4066 } target_s390_regs_common
;
4070 double fprs
[__NUM_FPRS
];
4071 } target_s390_fp_regs
;
4074 target_s390_regs_common regs
;
4075 target_s390_fp_regs fpregs
;
4078 struct target_sigcontext
{
4079 target_ulong oldmask
[_SIGCONTEXT_NSIG_WORDS
];
4080 target_sigregs
*sregs
;
4084 uint8_t callee_used_stack
[__SIGNAL_FRAMESIZE
];
4085 struct target_sigcontext sc
;
4086 target_sigregs sregs
;
4088 uint8_t retcode
[S390_SYSCALL_SIZE
];
4091 struct target_ucontext
{
4092 target_ulong tuc_flags
;
4093 struct target_ucontext
*tuc_link
;
4094 target_stack_t tuc_stack
;
4095 target_sigregs tuc_mcontext
;
4096 target_sigset_t tuc_sigmask
; /* mask last for extensibility */
4100 uint8_t callee_used_stack
[__SIGNAL_FRAMESIZE
];
4101 uint8_t retcode
[S390_SYSCALL_SIZE
];
4102 struct target_siginfo info
;
4103 struct target_ucontext uc
;
4106 static inline abi_ulong
4107 get_sigframe(struct target_sigaction
*ka
, CPUS390XState
*env
, size_t frame_size
)
4111 /* Default to using normal stack */
4114 /* This is the X/Open sanctioned signal stack switching. */
4115 if (ka
->sa_flags
& TARGET_SA_ONSTACK
) {
4116 if (!sas_ss_flags(sp
)) {
4117 sp
= target_sigaltstack_used
.ss_sp
+
4118 target_sigaltstack_used
.ss_size
;
4122 /* This is the legacy signal stack switching. */
4123 else if (/* FIXME !user_mode(regs) */ 0 &&
4124 !(ka
->sa_flags
& TARGET_SA_RESTORER
) &&
4126 sp
= (abi_ulong
) ka
->sa_restorer
;
4129 return (sp
- frame_size
) & -8ul;
4132 static void save_sigregs(CPUS390XState
*env
, target_sigregs
*sregs
)
4135 //save_access_regs(current->thread.acrs); FIXME
4137 /* Copy a 'clean' PSW mask to the user to avoid leaking
4138 information about whether PER is currently on. */
4139 __put_user(env
->psw
.mask
, &sregs
->regs
.psw
.mask
);
4140 __put_user(env
->psw
.addr
, &sregs
->regs
.psw
.addr
);
4141 for (i
= 0; i
< 16; i
++) {
4142 __put_user(env
->regs
[i
], &sregs
->regs
.gprs
[i
]);
4144 for (i
= 0; i
< 16; i
++) {
4145 __put_user(env
->aregs
[i
], &sregs
->regs
.acrs
[i
]);
4148 * We have to store the fp registers to current->thread.fp_regs
4149 * to merge them with the emulated registers.
4151 //save_fp_regs(¤t->thread.fp_regs); FIXME
4152 for (i
= 0; i
< 16; i
++) {
4153 __put_user(env
->fregs
[i
].ll
, &sregs
->fpregs
.fprs
[i
]);
4157 static void setup_frame(int sig
, struct target_sigaction
*ka
,
4158 target_sigset_t
*set
, CPUS390XState
*env
)
4161 abi_ulong frame_addr
;
4163 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
4164 qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__
,
4165 (unsigned long long)frame_addr
);
4166 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0)) {
4170 qemu_log("%s: 1\n", __FUNCTION__
);
4171 if (__put_user(set
->sig
[0], &frame
->sc
.oldmask
[0])) {
4175 save_sigregs(env
, &frame
->sregs
);
4177 __put_user((abi_ulong
)(unsigned long)&frame
->sregs
,
4178 (abi_ulong
*)&frame
->sc
.sregs
);
4180 /* Set up to return from userspace. If provided, use a stub
4181 already in userspace. */
4182 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
4183 env
->regs
[14] = (unsigned long)
4184 ka
->sa_restorer
| PSW_ADDR_AMODE
;
4186 env
->regs
[14] = (unsigned long)
4187 frame
->retcode
| PSW_ADDR_AMODE
;
4188 if (__put_user(S390_SYSCALL_OPCODE
| TARGET_NR_sigreturn
,
4189 (uint16_t *)(frame
->retcode
)))
4193 /* Set up backchain. */
4194 if (__put_user(env
->regs
[15], (abi_ulong
*) frame
)) {
4198 /* Set up registers for signal handler */
4199 env
->regs
[15] = frame_addr
;
4200 env
->psw
.addr
= (target_ulong
) ka
->_sa_handler
| PSW_ADDR_AMODE
;
4202 env
->regs
[2] = sig
; //map_signal(sig);
4203 env
->regs
[3] = frame_addr
+= offsetof(typeof(*frame
), sc
);
4205 /* We forgot to include these in the sigcontext.
4206 To avoid breaking binary compatibility, they are passed as args. */
4207 env
->regs
[4] = 0; // FIXME: no clue... current->thread.trap_no;
4208 env
->regs
[5] = 0; // FIXME: no clue... current->thread.prot_addr;
4210 /* Place signal number on stack to allow backtrace from handler. */
4211 if (__put_user(env
->regs
[2], (int *) &frame
->signo
)) {
4214 unlock_user_struct(frame
, frame_addr
, 1);
4218 qemu_log("%s: give_sigsegv\n", __FUNCTION__
);
4219 unlock_user_struct(frame
, frame_addr
, 1);
4220 force_sig(TARGET_SIGSEGV
);
4223 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
4224 target_siginfo_t
*info
,
4225 target_sigset_t
*set
, CPUS390XState
*env
)
4229 abi_ulong frame_addr
;
4231 frame_addr
= get_sigframe(ka
, env
, sizeof *frame
);
4232 qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__
,
4233 (unsigned long long)frame_addr
);
4234 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0)) {
4238 qemu_log("%s: 1\n", __FUNCTION__
);
4239 if (copy_siginfo_to_user(&frame
->info
, info
)) {
4243 /* Create the ucontext. */
4244 __put_user(0, &frame
->uc
.tuc_flags
);
4245 __put_user((abi_ulong
)0, (abi_ulong
*)&frame
->uc
.tuc_link
);
4246 __put_user(target_sigaltstack_used
.ss_sp
, &frame
->uc
.tuc_stack
.ss_sp
);
4247 __put_user(sas_ss_flags(get_sp_from_cpustate(env
)),
4248 &frame
->uc
.tuc_stack
.ss_flags
);
4249 __put_user(target_sigaltstack_used
.ss_size
, &frame
->uc
.tuc_stack
.ss_size
);
4250 save_sigregs(env
, &frame
->uc
.tuc_mcontext
);
4251 for (i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
4252 __put_user((abi_ulong
)set
->sig
[i
],
4253 (abi_ulong
*)&frame
->uc
.tuc_sigmask
.sig
[i
]);
4256 /* Set up to return from userspace. If provided, use a stub
4257 already in userspace. */
4258 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
4259 env
->regs
[14] = (unsigned long) ka
->sa_restorer
| PSW_ADDR_AMODE
;
4261 env
->regs
[14] = (unsigned long) frame
->retcode
| PSW_ADDR_AMODE
;
4262 if (__put_user(S390_SYSCALL_OPCODE
| TARGET_NR_rt_sigreturn
,
4263 (uint16_t *)(frame
->retcode
))) {
4268 /* Set up backchain. */
4269 if (__put_user(env
->regs
[15], (abi_ulong
*) frame
)) {
4273 /* Set up registers for signal handler */
4274 env
->regs
[15] = frame_addr
;
4275 env
->psw
.addr
= (target_ulong
) ka
->_sa_handler
| PSW_ADDR_AMODE
;
4277 env
->regs
[2] = sig
; //map_signal(sig);
4278 env
->regs
[3] = frame_addr
+ offsetof(typeof(*frame
), info
);
4279 env
->regs
[4] = frame_addr
+ offsetof(typeof(*frame
), uc
);
4283 qemu_log("%s: give_sigsegv\n", __FUNCTION__
);
4284 unlock_user_struct(frame
, frame_addr
, 1);
4285 force_sig(TARGET_SIGSEGV
);
4289 restore_sigregs(CPUS390XState
*env
, target_sigregs
*sc
)
4294 for (i
= 0; i
< 16; i
++) {
4295 err
|= __get_user(env
->regs
[i
], &sc
->regs
.gprs
[i
]);
4298 err
|= __get_user(env
->psw
.mask
, &sc
->regs
.psw
.mask
);
4299 qemu_log("%s: sc->regs.psw.addr 0x%llx env->psw.addr 0x%llx\n",
4300 __FUNCTION__
, (unsigned long long)sc
->regs
.psw
.addr
,
4301 (unsigned long long)env
->psw
.addr
);
4302 err
|= __get_user(env
->psw
.addr
, &sc
->regs
.psw
.addr
);
4303 /* FIXME: 31-bit -> | PSW_ADDR_AMODE */
4305 for (i
= 0; i
< 16; i
++) {
4306 err
|= __get_user(env
->aregs
[i
], &sc
->regs
.acrs
[i
]);
4308 for (i
= 0; i
< 16; i
++) {
4309 err
|= __get_user(env
->fregs
[i
].ll
, &sc
->fpregs
.fprs
[i
]);
4315 long do_sigreturn(CPUS390XState
*env
)
4318 abi_ulong frame_addr
= env
->regs
[15];
4319 qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__
,
4320 (unsigned long long)frame_addr
);
4321 target_sigset_t target_set
;
4324 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1)) {
4327 if (__get_user(target_set
.sig
[0], &frame
->sc
.oldmask
[0])) {
4331 target_to_host_sigset_internal(&set
, &target_set
);
4332 sigprocmask(SIG_SETMASK
, &set
, NULL
); /* ~_BLOCKABLE? */
4334 if (restore_sigregs(env
, &frame
->sregs
)) {
4338 unlock_user_struct(frame
, frame_addr
, 0);
4339 return env
->regs
[2];
4342 unlock_user_struct(frame
, frame_addr
, 0);
4343 force_sig(TARGET_SIGSEGV
);
4347 long do_rt_sigreturn(CPUS390XState
*env
)
4350 abi_ulong frame_addr
= env
->regs
[15];
4351 qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__
,
4352 (unsigned long long)frame_addr
);
4355 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1)) {
4358 target_to_host_sigset(&set
, &frame
->uc
.tuc_sigmask
);
4360 sigprocmask(SIG_SETMASK
, &set
, NULL
); /* ~_BLOCKABLE? */
4362 if (restore_sigregs(env
, &frame
->uc
.tuc_mcontext
)) {
4366 if (do_sigaltstack(frame_addr
+ offsetof(rt_sigframe
, uc
.tuc_stack
), 0,
4367 get_sp_from_cpustate(env
)) == -EFAULT
) {
4370 unlock_user_struct(frame
, frame_addr
, 0);
4371 return env
->regs
[2];
4374 unlock_user_struct(frame
, frame_addr
, 0);
4375 force_sig(TARGET_SIGSEGV
);
4379 #elif defined(TARGET_PPC) && !defined(TARGET_PPC64)
4381 /* FIXME: Many of the structures are defined for both PPC and PPC64, but
4382 the signal handling is different enough that we haven't implemented
4383 support for PPC64 yet. Hence the restriction above.
4385 There are various #if'd blocks for code for TARGET_PPC64. These
4386 blocks should go away so that we can successfully run 32-bit and
4387 64-bit binaries on a QEMU configured for PPC64. */
4389 /* Size of dummy stack frame allocated when calling signal handler.
4390 See arch/powerpc/include/asm/ptrace.h. */
4391 #if defined(TARGET_PPC64)
4392 #define SIGNAL_FRAMESIZE 128
4394 #define SIGNAL_FRAMESIZE 64
4397 /* See arch/powerpc/include/asm/sigcontext.h. */
4398 struct target_sigcontext
{
4399 target_ulong _unused
[4];
4401 #if defined(TARGET_PPC64)
4404 target_ulong handler
;
4405 target_ulong oldmask
;
4406 target_ulong regs
; /* struct pt_regs __user * */
4407 /* TODO: PPC64 includes extra bits here. */
4410 /* Indices for target_mcontext.mc_gregs, below.
4411 See arch/powerpc/include/asm/ptrace.h for details. */
4447 TARGET_PT_ORIG_R3
= 34,
4452 /* Yes, there are two registers with #39. One is 64-bit only. */
4454 TARGET_PT_SOFTE
= 39,
4455 TARGET_PT_TRAP
= 40,
4457 TARGET_PT_DSISR
= 42,
4458 TARGET_PT_RESULT
= 43,
4459 TARGET_PT_REGS_COUNT
= 44
4462 /* See arch/powerpc/include/asm/ucontext.h. Only used for 32-bit PPC;
4463 on 64-bit PPC, sigcontext and mcontext are one and the same. */
4464 struct target_mcontext
{
4465 target_ulong mc_gregs
[48];
4466 /* Includes fpscr. */
4467 uint64_t mc_fregs
[33];
4468 target_ulong mc_pad
[2];
4469 /* We need to handle Altivec and SPE at the same time, which no
4470 kernel needs to do. Fortunately, the kernel defines this bit to
4471 be Altivec-register-large all the time, rather than trying to
4472 twiddle it based on the specific platform. */
4474 /* SPE vector registers. One extra for SPEFSCR. */
4476 /* Altivec vector registers. The packing of VSCR and VRSAVE
4477 varies depending on whether we're PPC64 or not: PPC64 splits
4478 them apart; PPC32 stuffs them together. */
4479 #if defined(TARGET_PPC64)
4480 #define QEMU_NVRREG 34
4482 #define QEMU_NVRREG 33
4484 ppc_avr_t altivec
[QEMU_NVRREG
];
4486 } mc_vregs
__attribute__((__aligned__(16)));
4489 struct target_ucontext
{
4490 target_ulong tuc_flags
;
4491 target_ulong tuc_link
; /* struct ucontext __user * */
4492 struct target_sigaltstack tuc_stack
;
4493 #if !defined(TARGET_PPC64)
4495 target_ulong tuc_regs
; /* struct mcontext __user *
4496 points to uc_mcontext field */
4498 target_sigset_t tuc_sigmask
;
4499 #if defined(TARGET_PPC64)
4500 target_sigset_t unused
[15]; /* Allow for uc_sigmask growth */
4501 struct target_sigcontext tuc_mcontext
;
4503 int32_t tuc_maskext
[30];
4504 int32_t tuc_pad2
[3];
4505 struct target_mcontext tuc_mcontext
;
4509 /* See arch/powerpc/kernel/signal_32.c. */
4510 struct target_sigframe
{
4511 struct target_sigcontext sctx
;
4512 struct target_mcontext mctx
;
4516 struct target_rt_sigframe
{
4517 struct target_siginfo info
;
4518 struct target_ucontext uc
;
4522 /* We use the mc_pad field for the signal return trampoline. */
4523 #define tramp mc_pad
4525 /* See arch/powerpc/kernel/signal.c. */
4526 static target_ulong
get_sigframe(struct target_sigaction
*ka
,
4530 target_ulong oldsp
, newsp
;
4532 oldsp
= env
->gpr
[1];
4534 if ((ka
->sa_flags
& TARGET_SA_ONSTACK
) &&
4535 (sas_ss_flags(oldsp
) == 0)) {
4536 oldsp
= (target_sigaltstack_used
.ss_sp
4537 + target_sigaltstack_used
.ss_size
);
4540 newsp
= (oldsp
- frame_size
) & ~0xFUL
;
4545 static int save_user_regs(CPUPPCState
*env
, struct target_mcontext
*frame
,
4548 target_ulong msr
= env
->msr
;
4550 target_ulong ccr
= 0;
4552 /* In general, the kernel attempts to be intelligent about what it
4553 needs to save for Altivec/FP/SPE registers. We don't care that
4554 much, so we just go ahead and save everything. */
4556 /* Save general registers. */
4557 for (i
= 0; i
< ARRAY_SIZE(env
->gpr
); i
++) {
4558 if (__put_user(env
->gpr
[i
], &frame
->mc_gregs
[i
])) {
4562 if (__put_user(env
->nip
, &frame
->mc_gregs
[TARGET_PT_NIP
])
4563 || __put_user(env
->ctr
, &frame
->mc_gregs
[TARGET_PT_CTR
])
4564 || __put_user(env
->lr
, &frame
->mc_gregs
[TARGET_PT_LNK
])
4565 || __put_user(env
->xer
, &frame
->mc_gregs
[TARGET_PT_XER
]))
4568 for (i
= 0; i
< ARRAY_SIZE(env
->crf
); i
++) {
4569 ccr
|= env
->crf
[i
] << (32 - ((i
+ 1) * 4));
4571 if (__put_user(ccr
, &frame
->mc_gregs
[TARGET_PT_CCR
]))
4574 /* Save Altivec registers if necessary. */
4575 if (env
->insns_flags
& PPC_ALTIVEC
) {
4576 for (i
= 0; i
< ARRAY_SIZE(env
->avr
); i
++) {
4577 ppc_avr_t
*avr
= &env
->avr
[i
];
4578 ppc_avr_t
*vreg
= &frame
->mc_vregs
.altivec
[i
];
4580 if (__put_user(avr
->u64
[0], &vreg
->u64
[0]) ||
4581 __put_user(avr
->u64
[1], &vreg
->u64
[1])) {
4585 /* Set MSR_VR in the saved MSR value to indicate that
4586 frame->mc_vregs contains valid data. */
4588 if (__put_user((uint32_t)env
->spr
[SPR_VRSAVE
],
4589 &frame
->mc_vregs
.altivec
[32].u32
[3]))
4593 /* Save floating point registers. */
4594 if (env
->insns_flags
& PPC_FLOAT
) {
4595 for (i
= 0; i
< ARRAY_SIZE(env
->fpr
); i
++) {
4596 if (__put_user(env
->fpr
[i
], &frame
->mc_fregs
[i
])) {
4600 if (__put_user((uint64_t) env
->fpscr
, &frame
->mc_fregs
[32]))
4604 /* Save SPE registers. The kernel only saves the high half. */
4605 if (env
->insns_flags
& PPC_SPE
) {
4606 #if defined(TARGET_PPC64)
4607 for (i
= 0; i
< ARRAY_SIZE(env
->gpr
); i
++) {
4608 if (__put_user(env
->gpr
[i
] >> 32, &frame
->mc_vregs
.spe
[i
])) {
4613 for (i
= 0; i
< ARRAY_SIZE(env
->gprh
); i
++) {
4614 if (__put_user(env
->gprh
[i
], &frame
->mc_vregs
.spe
[i
])) {
4619 /* Set MSR_SPE in the saved MSR value to indicate that
4620 frame->mc_vregs contains valid data. */
4622 if (__put_user(env
->spe_fscr
, &frame
->mc_vregs
.spe
[32]))
4627 if (__put_user(msr
, &frame
->mc_gregs
[TARGET_PT_MSR
]))
4630 /* Set up the sigreturn trampoline: li r0,sigret; sc. */
4632 if (__put_user(0x38000000UL
| sigret
, &frame
->tramp
[0]) ||
4633 __put_user(0x44000002UL
, &frame
->tramp
[1])) {
4641 static int restore_user_regs(CPUPPCState
*env
,
4642 struct target_mcontext
*frame
, int sig
)
4644 target_ulong save_r2
= 0;
4651 save_r2
= env
->gpr
[2];
4654 /* Restore general registers. */
4655 for (i
= 0; i
< ARRAY_SIZE(env
->gpr
); i
++) {
4656 if (__get_user(env
->gpr
[i
], &frame
->mc_gregs
[i
])) {
4660 if (__get_user(env
->nip
, &frame
->mc_gregs
[TARGET_PT_NIP
])
4661 || __get_user(env
->ctr
, &frame
->mc_gregs
[TARGET_PT_CTR
])
4662 || __get_user(env
->lr
, &frame
->mc_gregs
[TARGET_PT_LNK
])
4663 || __get_user(env
->xer
, &frame
->mc_gregs
[TARGET_PT_XER
]))
4665 if (__get_user(ccr
, &frame
->mc_gregs
[TARGET_PT_CCR
]))
4668 for (i
= 0; i
< ARRAY_SIZE(env
->crf
); i
++) {
4669 env
->crf
[i
] = (ccr
>> (32 - ((i
+ 1) * 4))) & 0xf;
4673 env
->gpr
[2] = save_r2
;
4676 if (__get_user(msr
, &frame
->mc_gregs
[TARGET_PT_MSR
]))
4679 /* If doing signal return, restore the previous little-endian mode. */
4681 env
->msr
= (env
->msr
& ~MSR_LE
) | (msr
& MSR_LE
);
4683 /* Restore Altivec registers if necessary. */
4684 if (env
->insns_flags
& PPC_ALTIVEC
) {
4685 for (i
= 0; i
< ARRAY_SIZE(env
->avr
); i
++) {
4686 ppc_avr_t
*avr
= &env
->avr
[i
];
4687 ppc_avr_t
*vreg
= &frame
->mc_vregs
.altivec
[i
];
4689 if (__get_user(avr
->u64
[0], &vreg
->u64
[0]) ||
4690 __get_user(avr
->u64
[1], &vreg
->u64
[1])) {
4694 /* Set MSR_VEC in the saved MSR value to indicate that
4695 frame->mc_vregs contains valid data. */
4696 if (__get_user(env
->spr
[SPR_VRSAVE
],
4697 (target_ulong
*)(&frame
->mc_vregs
.altivec
[32].u32
[3])))
4701 /* Restore floating point registers. */
4702 if (env
->insns_flags
& PPC_FLOAT
) {
4704 for (i
= 0; i
< ARRAY_SIZE(env
->fpr
); i
++) {
4705 if (__get_user(env
->fpr
[i
], &frame
->mc_fregs
[i
])) {
4709 if (__get_user(fpscr
, &frame
->mc_fregs
[32]))
4711 env
->fpscr
= (uint32_t) fpscr
;
4714 /* Save SPE registers. The kernel only saves the high half. */
4715 if (env
->insns_flags
& PPC_SPE
) {
4716 #if defined(TARGET_PPC64)
4717 for (i
= 0; i
< ARRAY_SIZE(env
->gpr
); i
++) {
4720 if (__get_user(hi
, &frame
->mc_vregs
.spe
[i
])) {
4723 env
->gpr
[i
] = ((uint64_t)hi
<< 32) | ((uint32_t) env
->gpr
[i
]);
4726 for (i
= 0; i
< ARRAY_SIZE(env
->gprh
); i
++) {
4727 if (__get_user(env
->gprh
[i
], &frame
->mc_vregs
.spe
[i
])) {
4732 if (__get_user(env
->spe_fscr
, &frame
->mc_vregs
.spe
[32]))
4739 static void setup_frame(int sig
, struct target_sigaction
*ka
,
4740 target_sigset_t
*set
, CPUPPCState
*env
)
4742 struct target_sigframe
*frame
;
4743 struct target_sigcontext
*sc
;
4744 target_ulong frame_addr
, newsp
;
4748 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
4749 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 1))
4753 signal
= current_exec_domain_sig(sig
);
4755 err
|= __put_user(ka
->_sa_handler
, &sc
->handler
);
4756 err
|= __put_user(set
->sig
[0], &sc
->oldmask
);
4757 #if defined(TARGET_PPC64)
4758 err
|= __put_user(set
->sig
[0] >> 32, &sc
->_unused
[3]);
4760 err
|= __put_user(set
->sig
[1], &sc
->_unused
[3]);
4762 err
|= __put_user(h2g(&frame
->mctx
), &sc
->regs
);
4763 err
|= __put_user(sig
, &sc
->signal
);
4765 /* Save user regs. */
4766 err
|= save_user_regs(env
, &frame
->mctx
, TARGET_NR_sigreturn
);
4768 /* The kernel checks for the presence of a VDSO here. We don't
4769 emulate a vdso, so use a sigreturn system call. */
4770 env
->lr
= (target_ulong
) h2g(frame
->mctx
.tramp
);
4772 /* Turn off all fp exceptions. */
4775 /* Create a stack frame for the caller of the handler. */
4776 newsp
= frame_addr
- SIGNAL_FRAMESIZE
;
4777 err
|= put_user(env
->gpr
[1], newsp
, target_ulong
);
4782 /* Set up registers for signal handler. */
4783 env
->gpr
[1] = newsp
;
4784 env
->gpr
[3] = signal
;
4785 env
->gpr
[4] = frame_addr
+ offsetof(struct target_sigframe
, sctx
);
4786 env
->nip
= (target_ulong
) ka
->_sa_handler
;
4787 /* Signal handlers are entered in big-endian mode. */
4788 env
->msr
&= ~MSR_LE
;
4790 unlock_user_struct(frame
, frame_addr
, 1);
4794 unlock_user_struct(frame
, frame_addr
, 1);
4795 qemu_log("segfaulting from setup_frame\n");
4796 force_sig(TARGET_SIGSEGV
);
4799 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
4800 target_siginfo_t
*info
,
4801 target_sigset_t
*set
, CPUPPCState
*env
)
4803 struct target_rt_sigframe
*rt_sf
;
4804 struct target_mcontext
*frame
;
4805 target_ulong rt_sf_addr
, newsp
= 0;
4809 rt_sf_addr
= get_sigframe(ka
, env
, sizeof(*rt_sf
));
4810 if (!lock_user_struct(VERIFY_WRITE
, rt_sf
, rt_sf_addr
, 1))
4813 signal
= current_exec_domain_sig(sig
);
4815 err
|= copy_siginfo_to_user(&rt_sf
->info
, info
);
4817 err
|= __put_user(0, &rt_sf
->uc
.tuc_flags
);
4818 err
|= __put_user(0, &rt_sf
->uc
.tuc_link
);
4819 err
|= __put_user((target_ulong
)target_sigaltstack_used
.ss_sp
,
4820 &rt_sf
->uc
.tuc_stack
.ss_sp
);
4821 err
|= __put_user(sas_ss_flags(env
->gpr
[1]),
4822 &rt_sf
->uc
.tuc_stack
.ss_flags
);
4823 err
|= __put_user(target_sigaltstack_used
.ss_size
,
4824 &rt_sf
->uc
.tuc_stack
.ss_size
);
4825 err
|= __put_user(h2g (&rt_sf
->uc
.tuc_mcontext
),
4826 &rt_sf
->uc
.tuc_regs
);
4827 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
4828 err
|= __put_user(set
->sig
[i
], &rt_sf
->uc
.tuc_sigmask
.sig
[i
]);
4831 frame
= &rt_sf
->uc
.tuc_mcontext
;
4832 err
|= save_user_regs(env
, frame
, TARGET_NR_rt_sigreturn
);
4834 /* The kernel checks for the presence of a VDSO here. We don't
4835 emulate a vdso, so use a sigreturn system call. */
4836 env
->lr
= (target_ulong
) h2g(frame
->tramp
);
4838 /* Turn off all fp exceptions. */
4841 /* Create a stack frame for the caller of the handler. */
4842 newsp
= rt_sf_addr
- (SIGNAL_FRAMESIZE
+ 16);
4843 err
|= __put_user(env
->gpr
[1], (target_ulong
*)(uintptr_t) newsp
);
4848 /* Set up registers for signal handler. */
4849 env
->gpr
[1] = newsp
;
4850 env
->gpr
[3] = (target_ulong
) signal
;
4851 env
->gpr
[4] = (target_ulong
) h2g(&rt_sf
->info
);
4852 env
->gpr
[5] = (target_ulong
) h2g(&rt_sf
->uc
);
4853 env
->gpr
[6] = (target_ulong
) h2g(rt_sf
);
4854 env
->nip
= (target_ulong
) ka
->_sa_handler
;
4855 /* Signal handlers are entered in big-endian mode. */
4856 env
->msr
&= ~MSR_LE
;
4858 unlock_user_struct(rt_sf
, rt_sf_addr
, 1);
4862 unlock_user_struct(rt_sf
, rt_sf_addr
, 1);
4863 qemu_log("segfaulting from setup_rt_frame\n");
4864 force_sig(TARGET_SIGSEGV
);
4868 long do_sigreturn(CPUPPCState
*env
)
4870 struct target_sigcontext
*sc
= NULL
;
4871 struct target_mcontext
*sr
= NULL
;
4872 target_ulong sr_addr
= 0, sc_addr
;
4874 target_sigset_t set
;
4876 sc_addr
= env
->gpr
[1] + SIGNAL_FRAMESIZE
;
4877 if (!lock_user_struct(VERIFY_READ
, sc
, sc_addr
, 1))
4880 #if defined(TARGET_PPC64)
4881 set
.sig
[0] = sc
->oldmask
+ ((long)(sc
->_unused
[3]) << 32);
4883 if(__get_user(set
.sig
[0], &sc
->oldmask
) ||
4884 __get_user(set
.sig
[1], &sc
->_unused
[3]))
4887 target_to_host_sigset_internal(&blocked
, &set
);
4888 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
4890 if (__get_user(sr_addr
, &sc
->regs
))
4892 if (!lock_user_struct(VERIFY_READ
, sr
, sr_addr
, 1))
4894 if (restore_user_regs(env
, sr
, 1))
4897 unlock_user_struct(sr
, sr_addr
, 1);
4898 unlock_user_struct(sc
, sc_addr
, 1);
4899 return -TARGET_QEMU_ESIGRETURN
;
4902 unlock_user_struct(sr
, sr_addr
, 1);
4903 unlock_user_struct(sc
, sc_addr
, 1);
4904 qemu_log("segfaulting from do_sigreturn\n");
4905 force_sig(TARGET_SIGSEGV
);
4909 /* See arch/powerpc/kernel/signal_32.c. */
4910 static int do_setcontext(struct target_ucontext
*ucp
, CPUPPCState
*env
, int sig
)
4912 struct target_mcontext
*mcp
;
4913 target_ulong mcp_addr
;
4915 target_sigset_t set
;
4917 if (copy_from_user(&set
, h2g(ucp
) + offsetof(struct target_ucontext
, tuc_sigmask
),
4921 #if defined(TARGET_PPC64)
4922 fprintf (stderr
, "do_setcontext: not implemented\n");
4925 if (__get_user(mcp_addr
, &ucp
->tuc_regs
))
4928 if (!lock_user_struct(VERIFY_READ
, mcp
, mcp_addr
, 1))
4931 target_to_host_sigset_internal(&blocked
, &set
);
4932 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
4933 if (restore_user_regs(env
, mcp
, sig
))
4936 unlock_user_struct(mcp
, mcp_addr
, 1);
4940 unlock_user_struct(mcp
, mcp_addr
, 1);
4945 long do_rt_sigreturn(CPUPPCState
*env
)
4947 struct target_rt_sigframe
*rt_sf
= NULL
;
4948 target_ulong rt_sf_addr
;
4950 rt_sf_addr
= env
->gpr
[1] + SIGNAL_FRAMESIZE
+ 16;
4951 if (!lock_user_struct(VERIFY_READ
, rt_sf
, rt_sf_addr
, 1))
4954 if (do_setcontext(&rt_sf
->uc
, env
, 1))
4957 do_sigaltstack(rt_sf_addr
4958 + offsetof(struct target_rt_sigframe
, uc
.tuc_stack
),
4961 unlock_user_struct(rt_sf
, rt_sf_addr
, 1);
4962 return -TARGET_QEMU_ESIGRETURN
;
4965 unlock_user_struct(rt_sf
, rt_sf_addr
, 1);
4966 qemu_log("segfaulting from do_rt_sigreturn\n");
4967 force_sig(TARGET_SIGSEGV
);
4971 #elif defined(TARGET_M68K)
4973 struct target_sigcontext
{
4980 unsigned short sc_sr
;
4984 struct target_sigframe
4991 abi_ulong extramask
[TARGET_NSIG_WORDS
-1];
4992 struct target_sigcontext sc
;
4995 typedef int target_greg_t
;
4996 #define TARGET_NGREG 18
4997 typedef target_greg_t target_gregset_t
[TARGET_NGREG
];
4999 typedef struct target_fpregset
{
5002 } target_fpregset_t
;
5004 struct target_mcontext
{
5006 target_gregset_t gregs
;
5007 target_fpregset_t fpregs
;
5010 #define TARGET_MCONTEXT_VERSION 2
5012 struct target_ucontext
{
5013 abi_ulong tuc_flags
;
5015 target_stack_t tuc_stack
;
5016 struct target_mcontext tuc_mcontext
;
5017 abi_long tuc_filler
[80];
5018 target_sigset_t tuc_sigmask
;
5021 struct target_rt_sigframe
5028 struct target_siginfo info
;
5029 struct target_ucontext uc
;
5033 setup_sigcontext(struct target_sigcontext
*sc
, CPUM68KState
*env
,
5038 err
|= __put_user(mask
, &sc
->sc_mask
);
5039 err
|= __put_user(env
->aregs
[7], &sc
->sc_usp
);
5040 err
|= __put_user(env
->dregs
[0], &sc
->sc_d0
);
5041 err
|= __put_user(env
->dregs
[1], &sc
->sc_d1
);
5042 err
|= __put_user(env
->aregs
[0], &sc
->sc_a0
);
5043 err
|= __put_user(env
->aregs
[1], &sc
->sc_a1
);
5044 err
|= __put_user(env
->sr
, &sc
->sc_sr
);
5045 err
|= __put_user(env
->pc
, &sc
->sc_pc
);
5051 restore_sigcontext(CPUM68KState
*env
, struct target_sigcontext
*sc
, int *pd0
)
5056 err
|= __get_user(env
->aregs
[7], &sc
->sc_usp
);
5057 err
|= __get_user(env
->dregs
[1], &sc
->sc_d1
);
5058 err
|= __get_user(env
->aregs
[0], &sc
->sc_a0
);
5059 err
|= __get_user(env
->aregs
[1], &sc
->sc_a1
);
5060 err
|= __get_user(env
->pc
, &sc
->sc_pc
);
5061 err
|= __get_user(temp
, &sc
->sc_sr
);
5062 env
->sr
= (env
->sr
& 0xff00) | (temp
& 0xff);
5064 *pd0
= tswapl(sc
->sc_d0
);
5070 * Determine which stack to use..
5072 static inline abi_ulong
5073 get_sigframe(struct target_sigaction
*ka
, CPUM68KState
*regs
,
5078 sp
= regs
->aregs
[7];
5080 /* This is the X/Open sanctioned signal stack switching. */
5081 if ((ka
->sa_flags
& TARGET_SA_ONSTACK
) && (sas_ss_flags (sp
) == 0)) {
5082 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
5085 return ((sp
- frame_size
) & -8UL);
5088 static void setup_frame(int sig
, struct target_sigaction
*ka
,
5089 target_sigset_t
*set
, CPUM68KState
*env
)
5091 struct target_sigframe
*frame
;
5092 abi_ulong frame_addr
;
5093 abi_ulong retcode_addr
;
5098 frame_addr
= get_sigframe(ka
, env
, sizeof *frame
);
5099 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
5102 err
|= __put_user(sig
, &frame
->sig
);
5104 sc_addr
= frame_addr
+ offsetof(struct target_sigframe
, sc
);
5105 err
|= __put_user(sc_addr
, &frame
->psc
);
5107 err
|= setup_sigcontext(&frame
->sc
, env
, set
->sig
[0]);
5111 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
5112 if (__put_user(set
->sig
[i
], &frame
->extramask
[i
- 1]))
5116 /* Set up to return from userspace. */
5118 retcode_addr
= frame_addr
+ offsetof(struct target_sigframe
, retcode
);
5119 err
|= __put_user(retcode_addr
, &frame
->pretcode
);
5121 /* moveq #,d0; trap #0 */
5123 err
|= __put_user(0x70004e40 + (TARGET_NR_sigreturn
<< 16),
5124 (long *)(frame
->retcode
));
5129 /* Set up to return from userspace */
5131 env
->aregs
[7] = frame_addr
;
5132 env
->pc
= ka
->_sa_handler
;
5134 unlock_user_struct(frame
, frame_addr
, 1);
5138 unlock_user_struct(frame
, frame_addr
, 1);
5139 force_sig(TARGET_SIGSEGV
);
5142 static inline int target_rt_setup_ucontext(struct target_ucontext
*uc
,
5145 target_greg_t
*gregs
= uc
->tuc_mcontext
.gregs
;
5148 err
= __put_user(TARGET_MCONTEXT_VERSION
, &uc
->tuc_mcontext
.version
);
5149 err
|= __put_user(env
->dregs
[0], &gregs
[0]);
5150 err
|= __put_user(env
->dregs
[1], &gregs
[1]);
5151 err
|= __put_user(env
->dregs
[2], &gregs
[2]);
5152 err
|= __put_user(env
->dregs
[3], &gregs
[3]);
5153 err
|= __put_user(env
->dregs
[4], &gregs
[4]);
5154 err
|= __put_user(env
->dregs
[5], &gregs
[5]);
5155 err
|= __put_user(env
->dregs
[6], &gregs
[6]);
5156 err
|= __put_user(env
->dregs
[7], &gregs
[7]);
5157 err
|= __put_user(env
->aregs
[0], &gregs
[8]);
5158 err
|= __put_user(env
->aregs
[1], &gregs
[9]);
5159 err
|= __put_user(env
->aregs
[2], &gregs
[10]);
5160 err
|= __put_user(env
->aregs
[3], &gregs
[11]);
5161 err
|= __put_user(env
->aregs
[4], &gregs
[12]);
5162 err
|= __put_user(env
->aregs
[5], &gregs
[13]);
5163 err
|= __put_user(env
->aregs
[6], &gregs
[14]);
5164 err
|= __put_user(env
->aregs
[7], &gregs
[15]);
5165 err
|= __put_user(env
->pc
, &gregs
[16]);
5166 err
|= __put_user(env
->sr
, &gregs
[17]);
5171 static inline int target_rt_restore_ucontext(CPUM68KState
*env
,
5172 struct target_ucontext
*uc
,
5177 target_greg_t
*gregs
= uc
->tuc_mcontext
.gregs
;
5179 err
= __get_user(temp
, &uc
->tuc_mcontext
.version
);
5180 if (temp
!= TARGET_MCONTEXT_VERSION
)
5183 /* restore passed registers */
5184 err
|= __get_user(env
->dregs
[0], &gregs
[0]);
5185 err
|= __get_user(env
->dregs
[1], &gregs
[1]);
5186 err
|= __get_user(env
->dregs
[2], &gregs
[2]);
5187 err
|= __get_user(env
->dregs
[3], &gregs
[3]);
5188 err
|= __get_user(env
->dregs
[4], &gregs
[4]);
5189 err
|= __get_user(env
->dregs
[5], &gregs
[5]);
5190 err
|= __get_user(env
->dregs
[6], &gregs
[6]);
5191 err
|= __get_user(env
->dregs
[7], &gregs
[7]);
5192 err
|= __get_user(env
->aregs
[0], &gregs
[8]);
5193 err
|= __get_user(env
->aregs
[1], &gregs
[9]);
5194 err
|= __get_user(env
->aregs
[2], &gregs
[10]);
5195 err
|= __get_user(env
->aregs
[3], &gregs
[11]);
5196 err
|= __get_user(env
->aregs
[4], &gregs
[12]);
5197 err
|= __get_user(env
->aregs
[5], &gregs
[13]);
5198 err
|= __get_user(env
->aregs
[6], &gregs
[14]);
5199 err
|= __get_user(env
->aregs
[7], &gregs
[15]);
5200 err
|= __get_user(env
->pc
, &gregs
[16]);
5201 err
|= __get_user(temp
, &gregs
[17]);
5202 env
->sr
= (env
->sr
& 0xff00) | (temp
& 0xff);
5204 *pd0
= env
->dregs
[0];
5211 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
5212 target_siginfo_t
*info
,
5213 target_sigset_t
*set
, CPUM68KState
*env
)
5215 struct target_rt_sigframe
*frame
;
5216 abi_ulong frame_addr
;
5217 abi_ulong retcode_addr
;
5218 abi_ulong info_addr
;
5223 frame_addr
= get_sigframe(ka
, env
, sizeof *frame
);
5224 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
5227 err
|= __put_user(sig
, &frame
->sig
);
5229 info_addr
= frame_addr
+ offsetof(struct target_rt_sigframe
, info
);
5230 err
|= __put_user(info_addr
, &frame
->pinfo
);
5232 uc_addr
= frame_addr
+ offsetof(struct target_rt_sigframe
, uc
);
5233 err
|= __put_user(uc_addr
, &frame
->puc
);
5235 err
|= copy_siginfo_to_user(&frame
->info
, info
);
5237 /* Create the ucontext */
5239 err
|= __put_user(0, &frame
->uc
.tuc_flags
);
5240 err
|= __put_user(0, &frame
->uc
.tuc_link
);
5241 err
|= __put_user(target_sigaltstack_used
.ss_sp
,
5242 &frame
->uc
.tuc_stack
.ss_sp
);
5243 err
|= __put_user(sas_ss_flags(env
->aregs
[7]),
5244 &frame
->uc
.tuc_stack
.ss_flags
);
5245 err
|= __put_user(target_sigaltstack_used
.ss_size
,
5246 &frame
->uc
.tuc_stack
.ss_size
);
5247 err
|= target_rt_setup_ucontext(&frame
->uc
, env
);
5252 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
5253 if (__put_user(set
->sig
[i
], &frame
->uc
.tuc_sigmask
.sig
[i
]))
5257 /* Set up to return from userspace. */
5259 retcode_addr
= frame_addr
+ offsetof(struct target_sigframe
, retcode
);
5260 err
|= __put_user(retcode_addr
, &frame
->pretcode
);
5262 /* moveq #,d0; notb d0; trap #0 */
5264 err
|= __put_user(0x70004600 + ((TARGET_NR_rt_sigreturn
^ 0xff) << 16),
5265 (long *)(frame
->retcode
+ 0));
5266 err
|= __put_user(0x4e40, (short *)(frame
->retcode
+ 4));
5271 /* Set up to return from userspace */
5273 env
->aregs
[7] = frame_addr
;
5274 env
->pc
= ka
->_sa_handler
;
5276 unlock_user_struct(frame
, frame_addr
, 1);
5280 unlock_user_struct(frame
, frame_addr
, 1);
5281 force_sig(TARGET_SIGSEGV
);
5284 long do_sigreturn(CPUM68KState
*env
)
5286 struct target_sigframe
*frame
;
5287 abi_ulong frame_addr
= env
->aregs
[7] - 4;
5288 target_sigset_t target_set
;
5292 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
5295 /* set blocked signals */
5297 if (__get_user(target_set
.sig
[0], &frame
->sc
.sc_mask
))
5300 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
5301 if (__get_user(target_set
.sig
[i
], &frame
->extramask
[i
- 1]))
5305 target_to_host_sigset_internal(&set
, &target_set
);
5306 sigprocmask(SIG_SETMASK
, &set
, NULL
);
5308 /* restore registers */
5310 if (restore_sigcontext(env
, &frame
->sc
, &d0
))
5313 unlock_user_struct(frame
, frame_addr
, 0);
5317 unlock_user_struct(frame
, frame_addr
, 0);
5318 force_sig(TARGET_SIGSEGV
);
5322 long do_rt_sigreturn(CPUM68KState
*env
)
5324 struct target_rt_sigframe
*frame
;
5325 abi_ulong frame_addr
= env
->aregs
[7] - 4;
5326 target_sigset_t target_set
;
5330 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
5333 target_to_host_sigset_internal(&set
, &target_set
);
5334 sigprocmask(SIG_SETMASK
, &set
, NULL
);
5336 /* restore registers */
5338 if (target_rt_restore_ucontext(env
, &frame
->uc
, &d0
))
5341 if (do_sigaltstack(frame_addr
+
5342 offsetof(struct target_rt_sigframe
, uc
.tuc_stack
),
5343 0, get_sp_from_cpustate(env
)) == -EFAULT
)
5346 unlock_user_struct(frame
, frame_addr
, 0);
5350 unlock_user_struct(frame
, frame_addr
, 0);
5351 force_sig(TARGET_SIGSEGV
);
5355 #elif defined(TARGET_ALPHA)
5357 struct target_sigcontext
{
5358 abi_long sc_onstack
;
5362 abi_long sc_regs
[32];
5363 abi_long sc_ownedfp
;
5364 abi_long sc_fpregs
[32];
5366 abi_ulong sc_fp_control
;
5367 abi_ulong sc_reserved1
;
5368 abi_ulong sc_reserved2
;
5371 abi_ulong sc_traparg_a0
;
5372 abi_ulong sc_traparg_a1
;
5373 abi_ulong sc_traparg_a2
;
5374 abi_ulong sc_fp_trap_pc
;
5375 abi_ulong sc_fp_trigger_sum
;
5376 abi_ulong sc_fp_trigger_inst
;
5379 struct target_ucontext
{
5380 abi_ulong tuc_flags
;
5382 abi_ulong tuc_osf_sigmask
;
5383 target_stack_t tuc_stack
;
5384 struct target_sigcontext tuc_mcontext
;
5385 target_sigset_t tuc_sigmask
;
5388 struct target_sigframe
{
5389 struct target_sigcontext sc
;
5390 unsigned int retcode
[3];
5393 struct target_rt_sigframe
{
5394 target_siginfo_t info
;
5395 struct target_ucontext uc
;
5396 unsigned int retcode
[3];
5399 #define INSN_MOV_R30_R16 0x47fe0410
5400 #define INSN_LDI_R0 0x201f0000
5401 #define INSN_CALLSYS 0x00000083
5403 static int setup_sigcontext(struct target_sigcontext
*sc
, CPUAlphaState
*env
,
5404 abi_ulong frame_addr
, target_sigset_t
*set
)
5408 err
|= __put_user(on_sig_stack(frame_addr
), &sc
->sc_onstack
);
5409 err
|= __put_user(set
->sig
[0], &sc
->sc_mask
);
5410 err
|= __put_user(env
->pc
, &sc
->sc_pc
);
5411 err
|= __put_user(8, &sc
->sc_ps
);
5413 for (i
= 0; i
< 31; ++i
) {
5414 err
|= __put_user(env
->ir
[i
], &sc
->sc_regs
[i
]);
5416 err
|= __put_user(0, &sc
->sc_regs
[31]);
5418 for (i
= 0; i
< 31; ++i
) {
5419 err
|= __put_user(env
->fir
[i
], &sc
->sc_fpregs
[i
]);
5421 err
|= __put_user(0, &sc
->sc_fpregs
[31]);
5422 err
|= __put_user(cpu_alpha_load_fpcr(env
), &sc
->sc_fpcr
);
5424 err
|= __put_user(0, &sc
->sc_traparg_a0
); /* FIXME */
5425 err
|= __put_user(0, &sc
->sc_traparg_a1
); /* FIXME */
5426 err
|= __put_user(0, &sc
->sc_traparg_a2
); /* FIXME */
5431 static int restore_sigcontext(CPUAlphaState
*env
,
5432 struct target_sigcontext
*sc
)
5437 err
|= __get_user(env
->pc
, &sc
->sc_pc
);
5439 for (i
= 0; i
< 31; ++i
) {
5440 err
|= __get_user(env
->ir
[i
], &sc
->sc_regs
[i
]);
5442 for (i
= 0; i
< 31; ++i
) {
5443 err
|= __get_user(env
->fir
[i
], &sc
->sc_fpregs
[i
]);
5446 err
|= __get_user(fpcr
, &sc
->sc_fpcr
);
5447 cpu_alpha_store_fpcr(env
, fpcr
);
5452 static inline abi_ulong
get_sigframe(struct target_sigaction
*sa
,
5454 unsigned long framesize
)
5456 abi_ulong sp
= env
->ir
[IR_SP
];
5458 /* This is the X/Open sanctioned signal stack switching. */
5459 if ((sa
->sa_flags
& TARGET_SA_ONSTACK
) != 0 && !sas_ss_flags(sp
)) {
5460 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
5462 return (sp
- framesize
) & -32;
5465 static void setup_frame(int sig
, struct target_sigaction
*ka
,
5466 target_sigset_t
*set
, CPUAlphaState
*env
)
5468 abi_ulong frame_addr
, r26
;
5469 struct target_sigframe
*frame
;
5472 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
5473 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0)) {
5477 err
|= setup_sigcontext(&frame
->sc
, env
, frame_addr
, set
);
5479 if (ka
->sa_restorer
) {
5480 r26
= ka
->sa_restorer
;
5482 err
|= __put_user(INSN_MOV_R30_R16
, &frame
->retcode
[0]);
5483 err
|= __put_user(INSN_LDI_R0
+ TARGET_NR_sigreturn
,
5484 &frame
->retcode
[1]);
5485 err
|= __put_user(INSN_CALLSYS
, &frame
->retcode
[2]);
5490 unlock_user_struct(frame
, frame_addr
, 1);
5494 if (sig
== TARGET_SIGSEGV
) {
5495 ka
->_sa_handler
= TARGET_SIG_DFL
;
5497 force_sig(TARGET_SIGSEGV
);
5500 env
->ir
[IR_RA
] = r26
;
5501 env
->ir
[IR_PV
] = env
->pc
= ka
->_sa_handler
;
5502 env
->ir
[IR_A0
] = sig
;
5504 env
->ir
[IR_A2
] = frame_addr
+ offsetof(struct target_sigframe
, sc
);
5505 env
->ir
[IR_SP
] = frame_addr
;
5508 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
5509 target_siginfo_t
*info
,
5510 target_sigset_t
*set
, CPUAlphaState
*env
)
5512 abi_ulong frame_addr
, r26
;
5513 struct target_rt_sigframe
*frame
;
5516 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
5517 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0)) {
5521 err
|= copy_siginfo_to_user(&frame
->info
, info
);
5523 err
|= __put_user(0, &frame
->uc
.tuc_flags
);
5524 err
|= __put_user(0, &frame
->uc
.tuc_link
);
5525 err
|= __put_user(set
->sig
[0], &frame
->uc
.tuc_osf_sigmask
);
5526 err
|= __put_user(target_sigaltstack_used
.ss_sp
,
5527 &frame
->uc
.tuc_stack
.ss_sp
);
5528 err
|= __put_user(sas_ss_flags(env
->ir
[IR_SP
]),
5529 &frame
->uc
.tuc_stack
.ss_flags
);
5530 err
|= __put_user(target_sigaltstack_used
.ss_size
,
5531 &frame
->uc
.tuc_stack
.ss_size
);
5532 err
|= setup_sigcontext(&frame
->uc
.tuc_mcontext
, env
, frame_addr
, set
);
5533 for (i
= 0; i
< TARGET_NSIG_WORDS
; ++i
) {
5534 err
|= __put_user(set
->sig
[i
], &frame
->uc
.tuc_sigmask
.sig
[i
]);
5537 if (ka
->sa_restorer
) {
5538 r26
= ka
->sa_restorer
;
5540 err
|= __put_user(INSN_MOV_R30_R16
, &frame
->retcode
[0]);
5541 err
|= __put_user(INSN_LDI_R0
+ TARGET_NR_rt_sigreturn
,
5542 &frame
->retcode
[1]);
5543 err
|= __put_user(INSN_CALLSYS
, &frame
->retcode
[2]);
5550 if (sig
== TARGET_SIGSEGV
) {
5551 ka
->_sa_handler
= TARGET_SIG_DFL
;
5553 force_sig(TARGET_SIGSEGV
);
5556 env
->ir
[IR_RA
] = r26
;
5557 env
->ir
[IR_PV
] = env
->pc
= ka
->_sa_handler
;
5558 env
->ir
[IR_A0
] = sig
;
5559 env
->ir
[IR_A1
] = frame_addr
+ offsetof(struct target_rt_sigframe
, info
);
5560 env
->ir
[IR_A2
] = frame_addr
+ offsetof(struct target_rt_sigframe
, uc
);
5561 env
->ir
[IR_SP
] = frame_addr
;
5564 long do_sigreturn(CPUAlphaState
*env
)
5566 struct target_sigcontext
*sc
;
5567 abi_ulong sc_addr
= env
->ir
[IR_A0
];
5568 target_sigset_t target_set
;
5571 if (!lock_user_struct(VERIFY_READ
, sc
, sc_addr
, 1)) {
5575 target_sigemptyset(&target_set
);
5576 if (__get_user(target_set
.sig
[0], &sc
->sc_mask
)) {
5580 target_to_host_sigset_internal(&set
, &target_set
);
5581 sigprocmask(SIG_SETMASK
, &set
, NULL
);
5583 if (restore_sigcontext(env
, sc
)) {
5586 unlock_user_struct(sc
, sc_addr
, 0);
5587 return env
->ir
[IR_V0
];
5590 unlock_user_struct(sc
, sc_addr
, 0);
5591 force_sig(TARGET_SIGSEGV
);
5594 long do_rt_sigreturn(CPUAlphaState
*env
)
5596 abi_ulong frame_addr
= env
->ir
[IR_A0
];
5597 struct target_rt_sigframe
*frame
;
5600 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1)) {
5603 target_to_host_sigset(&set
, &frame
->uc
.tuc_sigmask
);
5604 sigprocmask(SIG_SETMASK
, &set
, NULL
);
5606 if (restore_sigcontext(env
, &frame
->uc
.tuc_mcontext
)) {
5609 if (do_sigaltstack(frame_addr
+ offsetof(struct target_rt_sigframe
,
5611 0, env
->ir
[IR_SP
]) == -EFAULT
) {
5615 unlock_user_struct(frame
, frame_addr
, 0);
5616 return env
->ir
[IR_V0
];
5620 unlock_user_struct(frame
, frame_addr
, 0);
5621 force_sig(TARGET_SIGSEGV
);
5626 static void setup_frame(int sig
, struct target_sigaction
*ka
,
5627 target_sigset_t
*set
, CPUArchState
*env
)
5629 fprintf(stderr
, "setup_frame: not implemented\n");
5632 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
5633 target_siginfo_t
*info
,
5634 target_sigset_t
*set
, CPUArchState
*env
)
5636 fprintf(stderr
, "setup_rt_frame: not implemented\n");
5639 long do_sigreturn(CPUArchState
*env
)
5641 fprintf(stderr
, "do_sigreturn: not implemented\n");
5642 return -TARGET_ENOSYS
;
5645 long do_rt_sigreturn(CPUArchState
*env
)
5647 fprintf(stderr
, "do_rt_sigreturn: not implemented\n");
5648 return -TARGET_ENOSYS
;
5653 void process_pending_signals(CPUArchState
*cpu_env
)
5655 CPUState
*cpu
= ENV_GET_CPU(cpu_env
);
5658 sigset_t set
, old_set
;
5659 target_sigset_t target_old_set
;
5660 struct emulated_sigtable
*k
;
5661 struct target_sigaction
*sa
;
5663 TaskState
*ts
= cpu_env
->opaque
;
5665 if (!ts
->signal_pending
)
5668 /* FIXME: This is not threadsafe. */
5670 for(sig
= 1; sig
<= TARGET_NSIG
; sig
++) {
5675 /* if no signal is pending, just return */
5676 ts
->signal_pending
= 0;
5681 fprintf(stderr
, "qemu: process signal %d\n", sig
);
5683 /* dequeue signal */
5689 sig
= gdb_handlesig(cpu
, sig
);
5692 handler
= TARGET_SIG_IGN
;
5694 sa
= &sigact_table
[sig
- 1];
5695 handler
= sa
->_sa_handler
;
5698 if (handler
== TARGET_SIG_DFL
) {
5699 /* default handler : ignore some signal. The other are job control or fatal */
5700 if (sig
== TARGET_SIGTSTP
|| sig
== TARGET_SIGTTIN
|| sig
== TARGET_SIGTTOU
) {
5701 kill(getpid(),SIGSTOP
);
5702 } else if (sig
!= TARGET_SIGCHLD
&&
5703 sig
!= TARGET_SIGURG
&&
5704 sig
!= TARGET_SIGWINCH
&&
5705 sig
!= TARGET_SIGCONT
) {
5708 } else if (handler
== TARGET_SIG_IGN
) {
5710 } else if (handler
== TARGET_SIG_ERR
) {
5713 /* compute the blocked signals during the handler execution */
5714 target_to_host_sigset(&set
, &sa
->sa_mask
);
5715 /* SA_NODEFER indicates that the current signal should not be
5716 blocked during the handler */
5717 if (!(sa
->sa_flags
& TARGET_SA_NODEFER
))
5718 sigaddset(&set
, target_to_host_signal(sig
));
5720 /* block signals in the handler using Linux */
5721 sigprocmask(SIG_BLOCK
, &set
, &old_set
);
5722 /* save the previous blocked signal state to restore it at the
5723 end of the signal execution (see do_sigreturn) */
5724 host_to_target_sigset_internal(&target_old_set
, &old_set
);
5726 /* if the CPU is in VM86 mode, we restore the 32 bit values */
5727 #if defined(TARGET_I386) && !defined(TARGET_X86_64)
5729 CPUX86State
*env
= cpu_env
;
5730 if (env
->eflags
& VM_MASK
)
5731 save_v86_state(env
);
5734 /* prepare the stack frame of the virtual CPU */
5735 #if defined(TARGET_ABI_MIPSN32) || defined(TARGET_ABI_MIPSN64)
5736 /* These targets do not have traditional signals. */
5737 setup_rt_frame(sig
, sa
, &q
->info
, &target_old_set
, cpu_env
);
5739 if (sa
->sa_flags
& TARGET_SA_SIGINFO
)
5740 setup_rt_frame(sig
, sa
, &q
->info
, &target_old_set
, cpu_env
);
5742 setup_frame(sig
, sa
, &target_old_set
, cpu_env
);
5744 if (sa
->sa_flags
& TARGET_SA_RESETHAND
)
5745 sa
->_sa_handler
= TARGET_SIG_DFL
;
5748 free_sigqueue(cpu_env
, q
);