2 * Emulation of Linux signals
4 * Copyright (c) 2003 Fabrice Bellard
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #include <sys/ucontext.h>
30 #include "target_signal.h"
32 //#define DEBUG_SIGNAL
34 struct target_sigaltstack target_sigaltstack_used
= {
37 .ss_flags
= TARGET_SS_DISABLE
,
40 static struct target_sigaction sigact_table
[TARGET_NSIG
];
42 static void host_signal_handler(int host_signum
, siginfo_t
*info
,
45 static uint8_t host_to_target_signal_table
[65] = {
46 [SIGHUP
] = TARGET_SIGHUP
,
47 [SIGINT
] = TARGET_SIGINT
,
48 [SIGQUIT
] = TARGET_SIGQUIT
,
49 [SIGILL
] = TARGET_SIGILL
,
50 [SIGTRAP
] = TARGET_SIGTRAP
,
51 [SIGABRT
] = TARGET_SIGABRT
,
52 /* [SIGIOT] = TARGET_SIGIOT,*/
53 [SIGBUS
] = TARGET_SIGBUS
,
54 [SIGFPE
] = TARGET_SIGFPE
,
55 [SIGKILL
] = TARGET_SIGKILL
,
56 [SIGUSR1
] = TARGET_SIGUSR1
,
57 [SIGSEGV
] = TARGET_SIGSEGV
,
58 [SIGUSR2
] = TARGET_SIGUSR2
,
59 [SIGPIPE
] = TARGET_SIGPIPE
,
60 [SIGALRM
] = TARGET_SIGALRM
,
61 [SIGTERM
] = TARGET_SIGTERM
,
63 [SIGSTKFLT
] = TARGET_SIGSTKFLT
,
65 [SIGCHLD
] = TARGET_SIGCHLD
,
66 [SIGCONT
] = TARGET_SIGCONT
,
67 [SIGSTOP
] = TARGET_SIGSTOP
,
68 [SIGTSTP
] = TARGET_SIGTSTP
,
69 [SIGTTIN
] = TARGET_SIGTTIN
,
70 [SIGTTOU
] = TARGET_SIGTTOU
,
71 [SIGURG
] = TARGET_SIGURG
,
72 [SIGXCPU
] = TARGET_SIGXCPU
,
73 [SIGXFSZ
] = TARGET_SIGXFSZ
,
74 [SIGVTALRM
] = TARGET_SIGVTALRM
,
75 [SIGPROF
] = TARGET_SIGPROF
,
76 [SIGWINCH
] = TARGET_SIGWINCH
,
77 [SIGIO
] = TARGET_SIGIO
,
78 [SIGPWR
] = TARGET_SIGPWR
,
79 [SIGSYS
] = TARGET_SIGSYS
,
80 /* next signals stay the same */
81 /* Nasty hack: Reverse SIGRTMIN and SIGRTMAX to avoid overlap with
82 host libpthread signals. This assumes noone actually uses SIGRTMAX :-/
83 To fix this properly we need to do manual signal delivery multiplexed
84 over a single host signal. */
85 [__SIGRTMIN
] = __SIGRTMAX
,
86 [__SIGRTMAX
] = __SIGRTMIN
,
88 static uint8_t target_to_host_signal_table
[65];
90 static inline int on_sig_stack(unsigned long sp
)
92 return (sp
- target_sigaltstack_used
.ss_sp
93 < target_sigaltstack_used
.ss_size
);
96 static inline int sas_ss_flags(unsigned long sp
)
98 return (target_sigaltstack_used
.ss_size
== 0 ? SS_DISABLE
99 : on_sig_stack(sp
) ? SS_ONSTACK
: 0);
102 static inline int host_to_target_signal(int sig
)
106 return host_to_target_signal_table
[sig
];
109 int target_to_host_signal(int sig
)
113 return target_to_host_signal_table
[sig
];
116 static inline void target_sigemptyset(target_sigset_t
*set
)
118 memset(set
, 0, sizeof(*set
));
121 static inline void target_sigaddset(target_sigset_t
*set
, int signum
)
124 abi_ulong mask
= (abi_ulong
)1 << (signum
% TARGET_NSIG_BPW
);
125 set
->sig
[signum
/ TARGET_NSIG_BPW
] |= mask
;
128 static inline int target_sigismember(const target_sigset_t
*set
, int signum
)
131 abi_ulong mask
= (abi_ulong
)1 << (signum
% TARGET_NSIG_BPW
);
132 return ((set
->sig
[signum
/ TARGET_NSIG_BPW
] & mask
) != 0);
135 static void host_to_target_sigset_internal(target_sigset_t
*d
,
139 target_sigemptyset(d
);
140 for (i
= 1; i
<= TARGET_NSIG
; i
++) {
141 if (sigismember(s
, i
)) {
142 target_sigaddset(d
, host_to_target_signal(i
));
147 void host_to_target_sigset(target_sigset_t
*d
, const sigset_t
*s
)
152 host_to_target_sigset_internal(&d1
, s
);
153 for(i
= 0;i
< TARGET_NSIG_WORDS
; i
++)
154 d
->sig
[i
] = tswapl(d1
.sig
[i
]);
157 static void target_to_host_sigset_internal(sigset_t
*d
,
158 const target_sigset_t
*s
)
162 for (i
= 1; i
<= TARGET_NSIG
; i
++) {
163 if (target_sigismember(s
, i
)) {
164 sigaddset(d
, target_to_host_signal(i
));
169 void target_to_host_sigset(sigset_t
*d
, const target_sigset_t
*s
)
174 for(i
= 0;i
< TARGET_NSIG_WORDS
; i
++)
175 s1
.sig
[i
] = tswapl(s
->sig
[i
]);
176 target_to_host_sigset_internal(d
, &s1
);
179 void host_to_target_old_sigset(abi_ulong
*old_sigset
,
180 const sigset_t
*sigset
)
183 host_to_target_sigset(&d
, sigset
);
184 *old_sigset
= d
.sig
[0];
187 void target_to_host_old_sigset(sigset_t
*sigset
,
188 const abi_ulong
*old_sigset
)
193 d
.sig
[0] = *old_sigset
;
194 for(i
= 1;i
< TARGET_NSIG_WORDS
; i
++)
196 target_to_host_sigset(sigset
, &d
);
199 /* siginfo conversion */
201 static inline void host_to_target_siginfo_noswap(target_siginfo_t
*tinfo
,
202 const siginfo_t
*info
)
205 sig
= host_to_target_signal(info
->si_signo
);
206 tinfo
->si_signo
= sig
;
208 tinfo
->si_code
= info
->si_code
;
209 if (sig
== SIGILL
|| sig
== SIGFPE
|| sig
== SIGSEGV
||
210 sig
== SIGBUS
|| sig
== SIGTRAP
) {
211 /* should never come here, but who knows. The information for
212 the target is irrelevant */
213 tinfo
->_sifields
._sigfault
._addr
= 0;
214 } else if (sig
== SIGIO
) {
215 tinfo
->_sifields
._sigpoll
._fd
= info
->si_fd
;
216 } else if (sig
>= TARGET_SIGRTMIN
) {
217 tinfo
->_sifields
._rt
._pid
= info
->si_pid
;
218 tinfo
->_sifields
._rt
._uid
= info
->si_uid
;
219 /* XXX: potential problem if 64 bit */
220 tinfo
->_sifields
._rt
._sigval
.sival_ptr
=
221 (abi_ulong
)(unsigned long)info
->si_value
.sival_ptr
;
225 static void tswap_siginfo(target_siginfo_t
*tinfo
,
226 const target_siginfo_t
*info
)
229 sig
= info
->si_signo
;
230 tinfo
->si_signo
= tswap32(sig
);
231 tinfo
->si_errno
= tswap32(info
->si_errno
);
232 tinfo
->si_code
= tswap32(info
->si_code
);
233 if (sig
== SIGILL
|| sig
== SIGFPE
|| sig
== SIGSEGV
||
234 sig
== SIGBUS
|| sig
== SIGTRAP
) {
235 tinfo
->_sifields
._sigfault
._addr
=
236 tswapl(info
->_sifields
._sigfault
._addr
);
237 } else if (sig
== SIGIO
) {
238 tinfo
->_sifields
._sigpoll
._fd
= tswap32(info
->_sifields
._sigpoll
._fd
);
239 } else if (sig
>= TARGET_SIGRTMIN
) {
240 tinfo
->_sifields
._rt
._pid
= tswap32(info
->_sifields
._rt
._pid
);
241 tinfo
->_sifields
._rt
._uid
= tswap32(info
->_sifields
._rt
._uid
);
242 tinfo
->_sifields
._rt
._sigval
.sival_ptr
=
243 tswapl(info
->_sifields
._rt
._sigval
.sival_ptr
);
248 void host_to_target_siginfo(target_siginfo_t
*tinfo
, const siginfo_t
*info
)
250 host_to_target_siginfo_noswap(tinfo
, info
);
251 tswap_siginfo(tinfo
, tinfo
);
254 /* XXX: we support only POSIX RT signals are used. */
255 /* XXX: find a solution for 64 bit (additional malloced data is needed) */
256 void target_to_host_siginfo(siginfo_t
*info
, const target_siginfo_t
*tinfo
)
258 info
->si_signo
= tswap32(tinfo
->si_signo
);
259 info
->si_errno
= tswap32(tinfo
->si_errno
);
260 info
->si_code
= tswap32(tinfo
->si_code
);
261 info
->si_pid
= tswap32(tinfo
->_sifields
._rt
._pid
);
262 info
->si_uid
= tswap32(tinfo
->_sifields
._rt
._uid
);
263 info
->si_value
.sival_ptr
=
264 (void *)(long)tswapl(tinfo
->_sifields
._rt
._sigval
.sival_ptr
);
267 void signal_init(void)
269 struct sigaction act
;
270 struct sigaction oact
;
274 /* generate signal conversion tables */
275 for(i
= 1; i
<= 64; i
++) {
276 if (host_to_target_signal_table
[i
] == 0)
277 host_to_target_signal_table
[i
] = i
;
279 for(i
= 1; i
<= 64; i
++) {
280 j
= host_to_target_signal_table
[i
];
281 target_to_host_signal_table
[j
] = i
;
284 /* set all host signal handlers. ALL signals are blocked during
285 the handlers to serialize them. */
286 memset(sigact_table
, 0, sizeof(sigact_table
));
288 sigfillset(&act
.sa_mask
);
289 act
.sa_flags
= SA_SIGINFO
;
290 act
.sa_sigaction
= host_signal_handler
;
291 for(i
= 1; i
<= TARGET_NSIG
; i
++) {
292 host_sig
= target_to_host_signal(i
);
293 sigaction(host_sig
, NULL
, &oact
);
294 if (oact
.sa_sigaction
== (void *)SIG_IGN
) {
295 sigact_table
[i
- 1]._sa_handler
= TARGET_SIG_IGN
;
296 } else if (oact
.sa_sigaction
== (void *)SIG_DFL
) {
297 sigact_table
[i
- 1]._sa_handler
= TARGET_SIG_DFL
;
299 /* If there's already a handler installed then something has
300 gone horribly wrong, so don't even try to handle that case. */
301 /* Install some handlers for our own use. */
302 if (host_sig
== SIGSEGV
|| host_sig
== SIGBUS
) {
303 sigaction(host_sig
, &act
, NULL
);
308 /* signal queue handling */
310 static inline struct sigqueue
*alloc_sigqueue(CPUState
*env
)
312 TaskState
*ts
= env
->opaque
;
313 struct sigqueue
*q
= ts
->first_free
;
316 ts
->first_free
= q
->next
;
320 static inline void free_sigqueue(CPUState
*env
, struct sigqueue
*q
)
322 TaskState
*ts
= env
->opaque
;
323 q
->next
= ts
->first_free
;
327 /* abort execution with signal */
328 static void __attribute((noreturn
)) force_sig(int sig
)
331 host_sig
= target_to_host_signal(sig
);
332 fprintf(stderr
, "qemu: uncaught target signal %d (%s) - exiting\n",
333 sig
, strsignal(host_sig
));
338 struct sigaction act
;
339 sigemptyset(&act
.sa_mask
);
340 act
.sa_flags
= SA_SIGINFO
;
341 act
.sa_sigaction
= SIG_DFL
;
342 sigaction(SIGABRT
, &act
, NULL
);
348 /* queue a signal so that it will be send to the virtual CPU as soon
350 int queue_signal(CPUState
*env
, int sig
, target_siginfo_t
*info
)
352 TaskState
*ts
= env
->opaque
;
353 struct emulated_sigtable
*k
;
354 struct sigqueue
*q
, **pq
;
357 #if defined(DEBUG_SIGNAL)
358 fprintf(stderr
, "queue_signal: sig=%d\n",
361 k
= &ts
->sigtab
[sig
- 1];
362 handler
= sigact_table
[sig
- 1]._sa_handler
;
363 if (handler
== TARGET_SIG_DFL
) {
364 /* default handler : ignore some signal. The other are fatal */
365 if (sig
!= TARGET_SIGCHLD
&&
366 sig
!= TARGET_SIGURG
&&
367 sig
!= TARGET_SIGWINCH
) {
370 return 0; /* indicate ignored */
372 } else if (handler
== TARGET_SIG_IGN
) {
375 } else if (handler
== TARGET_SIG_ERR
) {
379 if (sig
< TARGET_SIGRTMIN
) {
380 /* if non real time signal, we queue exactly one signal */
390 q
= alloc_sigqueue(env
);
401 /* signal that a new signal is pending */
402 ts
->signal_pending
= 1;
403 return 1; /* indicates that the signal was queued */
407 static void host_signal_handler(int host_signum
, siginfo_t
*info
,
411 target_siginfo_t tinfo
;
413 /* the CPU emulator uses some host signals to detect exceptions,
414 we we forward to it some signals */
415 if (host_signum
== SIGSEGV
|| host_signum
== SIGBUS
) {
416 if (cpu_signal_handler(host_signum
, info
, puc
))
420 /* get target signal number */
421 sig
= host_to_target_signal(host_signum
);
422 if (sig
< 1 || sig
> TARGET_NSIG
)
424 #if defined(DEBUG_SIGNAL)
425 fprintf(stderr
, "qemu: got signal %d\n", sig
);
427 host_to_target_siginfo_noswap(&tinfo
, info
);
428 if (queue_signal(thread_env
, sig
, &tinfo
) == 1) {
429 /* interrupt the virtual CPU as soon as possible */
430 cpu_interrupt(thread_env
, CPU_INTERRUPT_EXIT
);
434 /* do_sigaltstack() returns target values and errnos. */
435 /* compare linux/kernel/signal.c:do_sigaltstack() */
436 abi_long
do_sigaltstack(abi_ulong uss_addr
, abi_ulong uoss_addr
, abi_ulong sp
)
439 struct target_sigaltstack oss
;
441 /* XXX: test errors */
444 __put_user(target_sigaltstack_used
.ss_sp
, &oss
.ss_sp
);
445 __put_user(target_sigaltstack_used
.ss_size
, &oss
.ss_size
);
446 __put_user(sas_ss_flags(sp
), &oss
.ss_flags
);
451 struct target_sigaltstack
*uss
;
452 struct target_sigaltstack ss
;
454 ret
= -TARGET_EFAULT
;
455 if (!lock_user_struct(VERIFY_READ
, uss
, uss_addr
, 1)
456 || __get_user(ss
.ss_sp
, &uss
->ss_sp
)
457 || __get_user(ss
.ss_size
, &uss
->ss_size
)
458 || __get_user(ss
.ss_flags
, &uss
->ss_flags
))
460 unlock_user_struct(uss
, uss_addr
, 0);
463 if (on_sig_stack(sp
))
466 ret
= -TARGET_EINVAL
;
467 if (ss
.ss_flags
!= TARGET_SS_DISABLE
468 && ss
.ss_flags
!= TARGET_SS_ONSTACK
472 if (ss
.ss_flags
== TARGET_SS_DISABLE
) {
476 ret
= -TARGET_ENOMEM
;
477 if (ss
.ss_size
< MINSIGSTKSZ
)
481 target_sigaltstack_used
.ss_sp
= ss
.ss_sp
;
482 target_sigaltstack_used
.ss_size
= ss
.ss_size
;
486 ret
= -TARGET_EFAULT
;
487 if (copy_to_user(uoss_addr
, &oss
, sizeof(oss
)))
496 /* do_sigaction() return host values and errnos */
497 int do_sigaction(int sig
, const struct target_sigaction
*act
,
498 struct target_sigaction
*oact
)
500 struct target_sigaction
*k
;
501 struct sigaction act1
;
505 if (sig
< 1 || sig
> TARGET_NSIG
|| sig
== SIGKILL
|| sig
== SIGSTOP
)
507 k
= &sigact_table
[sig
- 1];
508 #if defined(DEBUG_SIGNAL)
509 fprintf(stderr
, "sigaction sig=%d act=0x%08x, oact=0x%08x\n",
510 sig
, (int)act
, (int)oact
);
513 oact
->_sa_handler
= tswapl(k
->_sa_handler
);
514 oact
->sa_flags
= tswapl(k
->sa_flags
);
515 #if !defined(TARGET_MIPS)
516 oact
->sa_restorer
= tswapl(k
->sa_restorer
);
518 oact
->sa_mask
= k
->sa_mask
;
521 /* FIXME: This is not threadsafe. */
522 k
->_sa_handler
= tswapl(act
->_sa_handler
);
523 k
->sa_flags
= tswapl(act
->sa_flags
);
524 #if !defined(TARGET_MIPS)
525 k
->sa_restorer
= tswapl(act
->sa_restorer
);
527 k
->sa_mask
= act
->sa_mask
;
529 /* we update the host linux signal state */
530 host_sig
= target_to_host_signal(sig
);
531 if (host_sig
!= SIGSEGV
&& host_sig
!= SIGBUS
) {
532 sigfillset(&act1
.sa_mask
);
533 act1
.sa_flags
= SA_SIGINFO
;
534 if (k
->sa_flags
& TARGET_SA_RESTART
)
535 act1
.sa_flags
|= SA_RESTART
;
536 /* NOTE: it is important to update the host kernel signal
537 ignore state to avoid getting unexpected interrupted
539 if (k
->_sa_handler
== TARGET_SIG_IGN
) {
540 act1
.sa_sigaction
= (void *)SIG_IGN
;
541 } else if (k
->_sa_handler
== TARGET_SIG_DFL
) {
542 act1
.sa_sigaction
= (void *)SIG_DFL
;
544 act1
.sa_sigaction
= host_signal_handler
;
546 ret
= sigaction(host_sig
, &act1
, NULL
);
553 #define offsetof(type, field) ((size_t) &((type *)0)->field)
556 static inline int copy_siginfo_to_user(target_siginfo_t
*tinfo
,
557 const target_siginfo_t
*info
)
559 tswap_siginfo(tinfo
, info
);
563 static inline int current_exec_domain_sig(int sig
)
565 return /* current->exec_domain && current->exec_domain->signal_invmap
566 && sig < 32 ? current->exec_domain->signal_invmap[sig] : */ sig
;
569 #if defined(TARGET_I386) && TARGET_ABI_BITS == 32
571 /* from the Linux kernel */
573 struct target_fpreg
{
574 uint16_t significand
[4];
578 struct target_fpxreg
{
579 uint16_t significand
[4];
584 struct target_xmmreg
{
585 abi_ulong element
[4];
588 struct target_fpstate
{
589 /* Regular FPU environment */
597 struct target_fpreg _st
[8];
599 uint16_t magic
; /* 0xffff = regular FPU data only */
601 /* FXSR FPU environment */
602 abi_ulong _fxsr_env
[6]; /* FXSR FPU env is ignored */
605 struct target_fpxreg _fxsr_st
[8]; /* FXSR FPU reg data is ignored */
606 struct target_xmmreg _xmm
[8];
607 abi_ulong padding
[56];
610 #define X86_FXSR_MAGIC 0x0000
612 struct target_sigcontext
{
630 abi_ulong esp_at_signal
;
632 abi_ulong fpstate
; /* pointer */
637 struct target_ucontext
{
640 target_stack_t tuc_stack
;
641 struct target_sigcontext tuc_mcontext
;
642 target_sigset_t tuc_sigmask
; /* mask last for extensibility */
649 struct target_sigcontext sc
;
650 struct target_fpstate fpstate
;
651 abi_ulong extramask
[TARGET_NSIG_WORDS
-1];
661 struct target_siginfo info
;
662 struct target_ucontext uc
;
663 struct target_fpstate fpstate
;
668 * Set up a signal frame.
671 /* XXX: save x87 state */
673 setup_sigcontext(struct target_sigcontext
*sc
, struct target_fpstate
*fpstate
,
674 CPUX86State
*env
, abi_ulong mask
, abi_ulong fpstate_addr
)
679 /* already locked in setup_frame() */
680 err
|= __put_user(env
->segs
[R_GS
].selector
, (unsigned int *)&sc
->gs
);
681 err
|= __put_user(env
->segs
[R_FS
].selector
, (unsigned int *)&sc
->fs
);
682 err
|= __put_user(env
->segs
[R_ES
].selector
, (unsigned int *)&sc
->es
);
683 err
|= __put_user(env
->segs
[R_DS
].selector
, (unsigned int *)&sc
->ds
);
684 err
|= __put_user(env
->regs
[R_EDI
], &sc
->edi
);
685 err
|= __put_user(env
->regs
[R_ESI
], &sc
->esi
);
686 err
|= __put_user(env
->regs
[R_EBP
], &sc
->ebp
);
687 err
|= __put_user(env
->regs
[R_ESP
], &sc
->esp
);
688 err
|= __put_user(env
->regs
[R_EBX
], &sc
->ebx
);
689 err
|= __put_user(env
->regs
[R_EDX
], &sc
->edx
);
690 err
|= __put_user(env
->regs
[R_ECX
], &sc
->ecx
);
691 err
|= __put_user(env
->regs
[R_EAX
], &sc
->eax
);
692 err
|= __put_user(env
->exception_index
, &sc
->trapno
);
693 err
|= __put_user(env
->error_code
, &sc
->err
);
694 err
|= __put_user(env
->eip
, &sc
->eip
);
695 err
|= __put_user(env
->segs
[R_CS
].selector
, (unsigned int *)&sc
->cs
);
696 err
|= __put_user(env
->eflags
, &sc
->eflags
);
697 err
|= __put_user(env
->regs
[R_ESP
], &sc
->esp_at_signal
);
698 err
|= __put_user(env
->segs
[R_SS
].selector
, (unsigned int *)&sc
->ss
);
700 cpu_x86_fsave(env
, fpstate_addr
, 1);
701 fpstate
->status
= fpstate
->sw
;
703 err
|= __put_user(magic
, &fpstate
->magic
);
704 err
|= __put_user(fpstate_addr
, &sc
->fpstate
);
706 /* non-iBCS2 extensions.. */
707 err
|= __put_user(mask
, &sc
->oldmask
);
708 err
|= __put_user(env
->cr
[2], &sc
->cr2
);
713 * Determine which stack to use..
716 static inline abi_ulong
717 get_sigframe(struct target_sigaction
*ka
, CPUX86State
*env
, size_t frame_size
)
721 /* Default to using normal stack */
722 esp
= env
->regs
[R_ESP
];
723 /* This is the X/Open sanctioned signal stack switching. */
724 if (ka
->sa_flags
& TARGET_SA_ONSTACK
) {
725 if (sas_ss_flags(esp
) == 0)
726 esp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
729 /* This is the legacy signal stack switching. */
731 if ((env
->segs
[R_SS
].selector
& 0xffff) != __USER_DS
&&
732 !(ka
->sa_flags
& TARGET_SA_RESTORER
) &&
734 esp
= (unsigned long) ka
->sa_restorer
;
736 return (esp
- frame_size
) & -8ul;
739 /* compare linux/arch/i386/kernel/signal.c:setup_frame() */
740 static void setup_frame(int sig
, struct target_sigaction
*ka
,
741 target_sigset_t
*set
, CPUX86State
*env
)
743 abi_ulong frame_addr
;
744 struct sigframe
*frame
;
747 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
749 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
752 err
|= __put_user(current_exec_domain_sig(sig
),
757 setup_sigcontext(&frame
->sc
, &frame
->fpstate
, env
, set
->sig
[0],
758 frame_addr
+ offsetof(struct sigframe
, fpstate
));
762 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
763 if (__put_user(set
->sig
[i
], &frame
->extramask
[i
- 1]))
767 /* Set up to return from userspace. If provided, use a stub
768 already in userspace. */
769 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
770 err
|= __put_user(ka
->sa_restorer
, &frame
->pretcode
);
773 abi_ulong retcode_addr
;
774 retcode_addr
= frame_addr
+ offsetof(struct sigframe
, retcode
);
775 err
|= __put_user(retcode_addr
, &frame
->pretcode
);
776 /* This is popl %eax ; movl $,%eax ; int $0x80 */
778 err
|= __put_user(val16
, (uint16_t *)(frame
->retcode
+0));
779 err
|= __put_user(TARGET_NR_sigreturn
, (int *)(frame
->retcode
+2));
781 err
|= __put_user(val16
, (uint16_t *)(frame
->retcode
+6));
787 /* Set up registers for signal handler */
788 env
->regs
[R_ESP
] = frame_addr
;
789 env
->eip
= ka
->_sa_handler
;
791 cpu_x86_load_seg(env
, R_DS
, __USER_DS
);
792 cpu_x86_load_seg(env
, R_ES
, __USER_DS
);
793 cpu_x86_load_seg(env
, R_SS
, __USER_DS
);
794 cpu_x86_load_seg(env
, R_CS
, __USER_CS
);
795 env
->eflags
&= ~TF_MASK
;
797 unlock_user_struct(frame
, frame_addr
, 1);
802 unlock_user_struct(frame
, frame_addr
, 1);
803 if (sig
== TARGET_SIGSEGV
)
804 ka
->_sa_handler
= TARGET_SIG_DFL
;
805 force_sig(TARGET_SIGSEGV
/* , current */);
808 /* compare linux/arch/i386/kernel/signal.c:setup_rt_frame() */
809 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
810 target_siginfo_t
*info
,
811 target_sigset_t
*set
, CPUX86State
*env
)
813 abi_ulong frame_addr
, addr
;
814 struct rt_sigframe
*frame
;
817 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
819 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
822 err
|= __put_user(current_exec_domain_sig(sig
),
824 addr
= frame_addr
+ offsetof(struct rt_sigframe
, info
);
825 err
|= __put_user(addr
, &frame
->pinfo
);
826 addr
= frame_addr
+ offsetof(struct rt_sigframe
, uc
);
827 err
|= __put_user(addr
, &frame
->puc
);
828 err
|= copy_siginfo_to_user(&frame
->info
, info
);
832 /* Create the ucontext. */
833 err
|= __put_user(0, &frame
->uc
.tuc_flags
);
834 err
|= __put_user(0, &frame
->uc
.tuc_link
);
835 err
|= __put_user(target_sigaltstack_used
.ss_sp
,
836 &frame
->uc
.tuc_stack
.ss_sp
);
837 err
|= __put_user(sas_ss_flags(get_sp_from_cpustate(env
)),
838 &frame
->uc
.tuc_stack
.ss_flags
);
839 err
|= __put_user(target_sigaltstack_used
.ss_size
,
840 &frame
->uc
.tuc_stack
.ss_size
);
841 err
|= setup_sigcontext(&frame
->uc
.tuc_mcontext
, &frame
->fpstate
,
843 frame_addr
+ offsetof(struct rt_sigframe
, fpstate
));
844 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
845 if (__put_user(set
->sig
[i
], &frame
->uc
.tuc_sigmask
.sig
[i
]))
849 /* Set up to return from userspace. If provided, use a stub
850 already in userspace. */
851 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
852 err
|= __put_user(ka
->sa_restorer
, &frame
->pretcode
);
855 addr
= frame_addr
+ offsetof(struct rt_sigframe
, retcode
);
856 err
|= __put_user(addr
, &frame
->pretcode
);
857 /* This is movl $,%eax ; int $0x80 */
858 err
|= __put_user(0xb8, (char *)(frame
->retcode
+0));
859 err
|= __put_user(TARGET_NR_rt_sigreturn
, (int *)(frame
->retcode
+1));
861 err
|= __put_user(val16
, (uint16_t *)(frame
->retcode
+5));
867 /* Set up registers for signal handler */
868 env
->regs
[R_ESP
] = frame_addr
;
869 env
->eip
= ka
->_sa_handler
;
871 cpu_x86_load_seg(env
, R_DS
, __USER_DS
);
872 cpu_x86_load_seg(env
, R_ES
, __USER_DS
);
873 cpu_x86_load_seg(env
, R_SS
, __USER_DS
);
874 cpu_x86_load_seg(env
, R_CS
, __USER_CS
);
875 env
->eflags
&= ~TF_MASK
;
877 unlock_user_struct(frame
, frame_addr
, 1);
882 unlock_user_struct(frame
, frame_addr
, 1);
883 if (sig
== TARGET_SIGSEGV
)
884 ka
->_sa_handler
= TARGET_SIG_DFL
;
885 force_sig(TARGET_SIGSEGV
/* , current */);
889 restore_sigcontext(CPUX86State
*env
, struct target_sigcontext
*sc
, int *peax
)
891 unsigned int err
= 0;
892 abi_ulong fpstate_addr
;
893 unsigned int tmpflags
;
895 cpu_x86_load_seg(env
, R_GS
, tswap16(sc
->gs
));
896 cpu_x86_load_seg(env
, R_FS
, tswap16(sc
->fs
));
897 cpu_x86_load_seg(env
, R_ES
, tswap16(sc
->es
));
898 cpu_x86_load_seg(env
, R_DS
, tswap16(sc
->ds
));
900 env
->regs
[R_EDI
] = tswapl(sc
->edi
);
901 env
->regs
[R_ESI
] = tswapl(sc
->esi
);
902 env
->regs
[R_EBP
] = tswapl(sc
->ebp
);
903 env
->regs
[R_ESP
] = tswapl(sc
->esp
);
904 env
->regs
[R_EBX
] = tswapl(sc
->ebx
);
905 env
->regs
[R_EDX
] = tswapl(sc
->edx
);
906 env
->regs
[R_ECX
] = tswapl(sc
->ecx
);
907 env
->eip
= tswapl(sc
->eip
);
909 cpu_x86_load_seg(env
, R_CS
, lduw(&sc
->cs
) | 3);
910 cpu_x86_load_seg(env
, R_SS
, lduw(&sc
->ss
) | 3);
912 tmpflags
= tswapl(sc
->eflags
);
913 env
->eflags
= (env
->eflags
& ~0x40DD5) | (tmpflags
& 0x40DD5);
914 // regs->orig_eax = -1; /* disable syscall checks */
916 fpstate_addr
= tswapl(sc
->fpstate
);
917 if (fpstate_addr
!= 0) {
918 if (!access_ok(VERIFY_READ
, fpstate_addr
,
919 sizeof(struct target_fpstate
)))
921 cpu_x86_frstor(env
, fpstate_addr
, 1);
924 *peax
= tswapl(sc
->eax
);
930 long do_sigreturn(CPUX86State
*env
)
932 struct sigframe
*frame
;
933 abi_ulong frame_addr
= env
->regs
[R_ESP
] - 8;
934 target_sigset_t target_set
;
938 #if defined(DEBUG_SIGNAL)
939 fprintf(stderr
, "do_sigreturn\n");
941 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
943 /* set blocked signals */
944 if (__get_user(target_set
.sig
[0], &frame
->sc
.oldmask
))
946 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
947 if (__get_user(target_set
.sig
[i
], &frame
->extramask
[i
- 1]))
951 target_to_host_sigset_internal(&set
, &target_set
);
952 sigprocmask(SIG_SETMASK
, &set
, NULL
);
954 /* restore registers */
955 if (restore_sigcontext(env
, &frame
->sc
, &eax
))
957 unlock_user_struct(frame
, frame_addr
, 0);
961 unlock_user_struct(frame
, frame_addr
, 0);
962 force_sig(TARGET_SIGSEGV
);
966 long do_rt_sigreturn(CPUX86State
*env
)
968 abi_ulong frame_addr
;
969 struct rt_sigframe
*frame
;
973 frame_addr
= env
->regs
[R_ESP
] - 4;
974 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
976 target_to_host_sigset(&set
, &frame
->uc
.tuc_sigmask
);
977 sigprocmask(SIG_SETMASK
, &set
, NULL
);
979 if (restore_sigcontext(env
, &frame
->uc
.tuc_mcontext
, &eax
))
982 if (do_sigaltstack(frame_addr
+ offsetof(struct rt_sigframe
, uc
.tuc_stack
), 0,
983 get_sp_from_cpustate(env
)) == -EFAULT
)
986 unlock_user_struct(frame
, frame_addr
, 0);
990 unlock_user_struct(frame
, frame_addr
, 0);
991 force_sig(TARGET_SIGSEGV
);
995 #elif defined(TARGET_ARM)
997 struct target_sigcontext
{
999 abi_ulong error_code
;
1018 abi_ulong fault_address
;
1021 struct target_ucontext_v1
{
1022 abi_ulong tuc_flags
;
1024 target_stack_t tuc_stack
;
1025 struct target_sigcontext tuc_mcontext
;
1026 target_sigset_t tuc_sigmask
; /* mask last for extensibility */
1029 struct target_ucontext_v2
{
1030 abi_ulong tuc_flags
;
1032 target_stack_t tuc_stack
;
1033 struct target_sigcontext tuc_mcontext
;
1034 target_sigset_t tuc_sigmask
; /* mask last for extensibility */
1035 char __unused
[128 - sizeof(sigset_t
)];
1036 abi_ulong tuc_regspace
[128] __attribute__((__aligned__(8)));
1041 struct target_sigcontext sc
;
1042 abi_ulong extramask
[TARGET_NSIG_WORDS
-1];
1048 struct target_ucontext_v2 uc
;
1052 struct rt_sigframe_v1
1056 struct target_siginfo info
;
1057 struct target_ucontext_v1 uc
;
1061 struct rt_sigframe_v2
1063 struct target_siginfo info
;
1064 struct target_ucontext_v2 uc
;
1068 #define TARGET_CONFIG_CPU_32 1
1071 * For ARM syscalls, we encode the syscall number into the instruction.
1073 #define SWI_SYS_SIGRETURN (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
1074 #define SWI_SYS_RT_SIGRETURN (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
1077 * For Thumb syscalls, we pass the syscall number via r7. We therefore
1078 * need two 16-bit instructions.
1080 #define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
1081 #define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
1083 static const abi_ulong retcodes
[4] = {
1084 SWI_SYS_SIGRETURN
, SWI_THUMB_SIGRETURN
,
1085 SWI_SYS_RT_SIGRETURN
, SWI_THUMB_RT_SIGRETURN
1089 #define __get_user_error(x,p,e) __get_user(x, p)
1091 static inline int valid_user_regs(CPUState
*regs
)
1097 setup_sigcontext(struct target_sigcontext
*sc
, /*struct _fpstate *fpstate,*/
1098 CPUState
*env
, abi_ulong mask
)
1100 __put_user(env
->regs
[0], &sc
->arm_r0
);
1101 __put_user(env
->regs
[1], &sc
->arm_r1
);
1102 __put_user(env
->regs
[2], &sc
->arm_r2
);
1103 __put_user(env
->regs
[3], &sc
->arm_r3
);
1104 __put_user(env
->regs
[4], &sc
->arm_r4
);
1105 __put_user(env
->regs
[5], &sc
->arm_r5
);
1106 __put_user(env
->regs
[6], &sc
->arm_r6
);
1107 __put_user(env
->regs
[7], &sc
->arm_r7
);
1108 __put_user(env
->regs
[8], &sc
->arm_r8
);
1109 __put_user(env
->regs
[9], &sc
->arm_r9
);
1110 __put_user(env
->regs
[10], &sc
->arm_r10
);
1111 __put_user(env
->regs
[11], &sc
->arm_fp
);
1112 __put_user(env
->regs
[12], &sc
->arm_ip
);
1113 __put_user(env
->regs
[13], &sc
->arm_sp
);
1114 __put_user(env
->regs
[14], &sc
->arm_lr
);
1115 __put_user(env
->regs
[15], &sc
->arm_pc
);
1116 #ifdef TARGET_CONFIG_CPU_32
1117 __put_user(cpsr_read(env
), &sc
->arm_cpsr
);
1120 __put_user(/* current->thread.trap_no */ 0, &sc
->trap_no
);
1121 __put_user(/* current->thread.error_code */ 0, &sc
->error_code
);
1122 __put_user(/* current->thread.address */ 0, &sc
->fault_address
);
1123 __put_user(mask
, &sc
->oldmask
);
1126 static inline abi_ulong
1127 get_sigframe(struct target_sigaction
*ka
, CPUState
*regs
, int framesize
)
1129 unsigned long sp
= regs
->regs
[13];
1132 * This is the X/Open sanctioned signal stack switching.
1134 if ((ka
->sa_flags
& TARGET_SA_ONSTACK
) && !sas_ss_flags(sp
))
1135 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
1137 * ATPCS B01 mandates 8-byte alignment
1139 return (sp
- framesize
) & ~7;
1143 setup_return(CPUState
*env
, struct target_sigaction
*ka
,
1144 abi_ulong
*rc
, abi_ulong frame_addr
, int usig
, abi_ulong rc_addr
)
1146 abi_ulong handler
= ka
->_sa_handler
;
1148 int thumb
= handler
& 1;
1150 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
1151 retcode
= ka
->sa_restorer
;
1153 unsigned int idx
= thumb
;
1155 if (ka
->sa_flags
& TARGET_SA_SIGINFO
)
1158 if (__put_user(retcodes
[idx
], rc
))
1161 flush_icache_range((abi_ulong
)rc
,
1162 (abi_ulong
)(rc
+ 1));
1164 retcode
= rc_addr
+ thumb
;
1167 env
->regs
[0] = usig
;
1168 env
->regs
[13] = frame_addr
;
1169 env
->regs
[14] = retcode
;
1170 env
->regs
[15] = handler
& (thumb
? ~1 : ~3);
1174 #ifdef TARGET_CONFIG_CPU_32
1182 static void setup_sigframe_v2(struct target_ucontext_v2
*uc
,
1183 target_sigset_t
*set
, CPUState
*env
)
1185 struct target_sigaltstack stack
;
1188 /* Clear all the bits of the ucontext we don't use. */
1189 memset(uc
, 0, offsetof(struct target_ucontext_v2
, tuc_mcontext
));
1191 memset(&stack
, 0, sizeof(stack
));
1192 __put_user(target_sigaltstack_used
.ss_sp
, &stack
.ss_sp
);
1193 __put_user(target_sigaltstack_used
.ss_size
, &stack
.ss_size
);
1194 __put_user(sas_ss_flags(get_sp_from_cpustate(env
)), &stack
.ss_flags
);
1195 memcpy(&uc
->tuc_stack
, &stack
, sizeof(stack
));
1197 setup_sigcontext(&uc
->tuc_mcontext
, env
, set
->sig
[0]);
1198 /* FIXME: Save coprocessor signal frame. */
1199 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
1200 __put_user(set
->sig
[i
], &uc
->tuc_sigmask
.sig
[i
]);
1204 /* compare linux/arch/arm/kernel/signal.c:setup_frame() */
1205 static void setup_frame_v1(int usig
, struct target_sigaction
*ka
,
1206 target_sigset_t
*set
, CPUState
*regs
)
1208 struct sigframe_v1
*frame
;
1209 abi_ulong frame_addr
= get_sigframe(ka
, regs
, sizeof(*frame
));
1212 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
1215 setup_sigcontext(&frame
->sc
, regs
, set
->sig
[0]);
1217 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
1218 if (__put_user(set
->sig
[i
], &frame
->extramask
[i
- 1]))
1222 setup_return(regs
, ka
, &frame
->retcode
, frame_addr
, usig
,
1223 frame_addr
+ offsetof(struct sigframe_v1
, retcode
));
1226 unlock_user_struct(frame
, frame_addr
, 1);
1229 static void setup_frame_v2(int usig
, struct target_sigaction
*ka
,
1230 target_sigset_t
*set
, CPUState
*regs
)
1232 struct sigframe_v2
*frame
;
1233 abi_ulong frame_addr
= get_sigframe(ka
, regs
, sizeof(*frame
));
1235 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
1238 setup_sigframe_v2(&frame
->uc
, set
, regs
);
1240 setup_return(regs
, ka
, &frame
->retcode
, frame_addr
, usig
,
1241 frame_addr
+ offsetof(struct sigframe_v2
, retcode
));
1243 unlock_user_struct(frame
, frame_addr
, 1);
1246 static void setup_frame(int usig
, struct target_sigaction
*ka
,
1247 target_sigset_t
*set
, CPUState
*regs
)
1249 if (get_osversion() >= 0x020612) {
1250 setup_frame_v2(usig
, ka
, set
, regs
);
1252 setup_frame_v1(usig
, ka
, set
, regs
);
1256 /* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */
1257 static void setup_rt_frame_v1(int usig
, struct target_sigaction
*ka
,
1258 target_siginfo_t
*info
,
1259 target_sigset_t
*set
, CPUState
*env
)
1261 struct rt_sigframe_v1
*frame
;
1262 abi_ulong frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
1263 struct target_sigaltstack stack
;
1265 abi_ulong info_addr
, uc_addr
;
1267 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
1270 info_addr
= frame_addr
+ offsetof(struct rt_sigframe_v1
, info
);
1271 __put_user(info_addr
, &frame
->pinfo
);
1272 uc_addr
= frame_addr
+ offsetof(struct rt_sigframe_v1
, uc
);
1273 __put_user(uc_addr
, &frame
->puc
);
1274 copy_siginfo_to_user(&frame
->info
, info
);
1276 /* Clear all the bits of the ucontext we don't use. */
1277 memset(&frame
->uc
, 0, offsetof(struct target_ucontext_v1
, tuc_mcontext
));
1279 memset(&stack
, 0, sizeof(stack
));
1280 __put_user(target_sigaltstack_used
.ss_sp
, &stack
.ss_sp
);
1281 __put_user(target_sigaltstack_used
.ss_size
, &stack
.ss_size
);
1282 __put_user(sas_ss_flags(get_sp_from_cpustate(env
)), &stack
.ss_flags
);
1283 memcpy(&frame
->uc
.tuc_stack
, &stack
, sizeof(stack
));
1285 setup_sigcontext(&frame
->uc
.tuc_mcontext
, env
, set
->sig
[0]);
1286 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
1287 if (__put_user(set
->sig
[i
], &frame
->uc
.tuc_sigmask
.sig
[i
]))
1291 setup_return(env
, ka
, &frame
->retcode
, frame_addr
, usig
,
1292 frame_addr
+ offsetof(struct rt_sigframe_v1
, retcode
));
1294 env
->regs
[1] = info_addr
;
1295 env
->regs
[2] = uc_addr
;
1298 unlock_user_struct(frame
, frame_addr
, 1);
1301 static void setup_rt_frame_v2(int usig
, struct target_sigaction
*ka
,
1302 target_siginfo_t
*info
,
1303 target_sigset_t
*set
, CPUState
*env
)
1305 struct rt_sigframe_v2
*frame
;
1306 abi_ulong frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
1307 abi_ulong info_addr
, uc_addr
;
1309 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
1312 info_addr
= frame_addr
+ offsetof(struct rt_sigframe_v2
, info
);
1313 uc_addr
= frame_addr
+ offsetof(struct rt_sigframe_v2
, uc
);
1314 copy_siginfo_to_user(&frame
->info
, info
);
1316 setup_sigframe_v2(&frame
->uc
, set
, env
);
1318 setup_return(env
, ka
, &frame
->retcode
, frame_addr
, usig
,
1319 frame_addr
+ offsetof(struct rt_sigframe_v2
, retcode
));
1321 env
->regs
[1] = info_addr
;
1322 env
->regs
[2] = uc_addr
;
1324 unlock_user_struct(frame
, frame_addr
, 1);
1327 static void setup_rt_frame(int usig
, struct target_sigaction
*ka
,
1328 target_siginfo_t
*info
,
1329 target_sigset_t
*set
, CPUState
*env
)
1331 if (get_osversion() >= 0x020612) {
1332 setup_rt_frame_v2(usig
, ka
, info
, set
, env
);
1334 setup_rt_frame_v1(usig
, ka
, info
, set
, env
);
1339 restore_sigcontext(CPUState
*env
, struct target_sigcontext
*sc
)
1344 __get_user_error(env
->regs
[0], &sc
->arm_r0
, err
);
1345 __get_user_error(env
->regs
[1], &sc
->arm_r1
, err
);
1346 __get_user_error(env
->regs
[2], &sc
->arm_r2
, err
);
1347 __get_user_error(env
->regs
[3], &sc
->arm_r3
, err
);
1348 __get_user_error(env
->regs
[4], &sc
->arm_r4
, err
);
1349 __get_user_error(env
->regs
[5], &sc
->arm_r5
, err
);
1350 __get_user_error(env
->regs
[6], &sc
->arm_r6
, err
);
1351 __get_user_error(env
->regs
[7], &sc
->arm_r7
, err
);
1352 __get_user_error(env
->regs
[8], &sc
->arm_r8
, err
);
1353 __get_user_error(env
->regs
[9], &sc
->arm_r9
, err
);
1354 __get_user_error(env
->regs
[10], &sc
->arm_r10
, err
);
1355 __get_user_error(env
->regs
[11], &sc
->arm_fp
, err
);
1356 __get_user_error(env
->regs
[12], &sc
->arm_ip
, err
);
1357 __get_user_error(env
->regs
[13], &sc
->arm_sp
, err
);
1358 __get_user_error(env
->regs
[14], &sc
->arm_lr
, err
);
1359 __get_user_error(env
->regs
[15], &sc
->arm_pc
, err
);
1360 #ifdef TARGET_CONFIG_CPU_32
1361 __get_user_error(cpsr
, &sc
->arm_cpsr
, err
);
1362 cpsr_write(env
, cpsr
, CPSR_USER
| CPSR_EXEC
);
1365 err
|= !valid_user_regs(env
);
1370 long do_sigreturn_v1(CPUState
*env
)
1372 abi_ulong frame_addr
;
1373 struct sigframe_v1
*frame
;
1374 target_sigset_t set
;
1379 * Since we stacked the signal on a 64-bit boundary,
1380 * then 'sp' should be word aligned here. If it's
1381 * not, then the user is trying to mess with us.
1383 if (env
->regs
[13] & 7)
1386 frame_addr
= env
->regs
[13];
1387 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
1390 if (__get_user(set
.sig
[0], &frame
->sc
.oldmask
))
1392 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
1393 if (__get_user(set
.sig
[i
], &frame
->extramask
[i
- 1]))
1397 target_to_host_sigset_internal(&host_set
, &set
);
1398 sigprocmask(SIG_SETMASK
, &host_set
, NULL
);
1400 if (restore_sigcontext(env
, &frame
->sc
))
1404 /* Send SIGTRAP if we're single-stepping */
1405 if (ptrace_cancel_bpt(current
))
1406 send_sig(SIGTRAP
, current
, 1);
1408 unlock_user_struct(frame
, frame_addr
, 0);
1409 return env
->regs
[0];
1412 unlock_user_struct(frame
, frame_addr
, 0);
1413 force_sig(SIGSEGV
/* , current */);
1417 static int do_sigframe_return_v2(CPUState
*env
, target_ulong frame_addr
,
1418 struct target_ucontext_v2
*uc
)
1422 target_to_host_sigset(&host_set
, &uc
->tuc_sigmask
);
1423 sigprocmask(SIG_SETMASK
, &host_set
, NULL
);
1425 if (restore_sigcontext(env
, &uc
->tuc_mcontext
))
1428 if (do_sigaltstack(frame_addr
+ offsetof(struct target_ucontext_v2
, tuc_stack
), 0, get_sp_from_cpustate(env
)) == -EFAULT
)
1432 /* Send SIGTRAP if we're single-stepping */
1433 if (ptrace_cancel_bpt(current
))
1434 send_sig(SIGTRAP
, current
, 1);
1440 long do_sigreturn_v2(CPUState
*env
)
1442 abi_ulong frame_addr
;
1443 struct sigframe_v2
*frame
;
1446 * Since we stacked the signal on a 64-bit boundary,
1447 * then 'sp' should be word aligned here. If it's
1448 * not, then the user is trying to mess with us.
1450 if (env
->regs
[13] & 7)
1453 frame_addr
= env
->regs
[13];
1454 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
1457 if (do_sigframe_return_v2(env
, frame_addr
, &frame
->uc
))
1460 unlock_user_struct(frame
, frame_addr
, 0);
1461 return env
->regs
[0];
1464 unlock_user_struct(frame
, frame_addr
, 0);
1465 force_sig(SIGSEGV
/* , current */);
1469 long do_sigreturn(CPUState
*env
)
1471 if (get_osversion() >= 0x020612) {
1472 return do_sigreturn_v2(env
);
1474 return do_sigreturn_v1(env
);
1478 long do_rt_sigreturn_v1(CPUState
*env
)
1480 abi_ulong frame_addr
;
1481 struct rt_sigframe_v1
*frame
;
1485 * Since we stacked the signal on a 64-bit boundary,
1486 * then 'sp' should be word aligned here. If it's
1487 * not, then the user is trying to mess with us.
1489 if (env
->regs
[13] & 7)
1492 frame_addr
= env
->regs
[13];
1493 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
1496 target_to_host_sigset(&host_set
, &frame
->uc
.tuc_sigmask
);
1497 sigprocmask(SIG_SETMASK
, &host_set
, NULL
);
1499 if (restore_sigcontext(env
, &frame
->uc
.tuc_mcontext
))
1502 if (do_sigaltstack(frame_addr
+ offsetof(struct rt_sigframe_v1
, uc
.tuc_stack
), 0, get_sp_from_cpustate(env
)) == -EFAULT
)
1506 /* Send SIGTRAP if we're single-stepping */
1507 if (ptrace_cancel_bpt(current
))
1508 send_sig(SIGTRAP
, current
, 1);
1510 unlock_user_struct(frame
, frame_addr
, 0);
1511 return env
->regs
[0];
1514 unlock_user_struct(frame
, frame_addr
, 0);
1515 force_sig(SIGSEGV
/* , current */);
1519 long do_rt_sigreturn_v2(CPUState
*env
)
1521 abi_ulong frame_addr
;
1522 struct rt_sigframe_v2
*frame
;
1525 * Since we stacked the signal on a 64-bit boundary,
1526 * then 'sp' should be word aligned here. If it's
1527 * not, then the user is trying to mess with us.
1529 if (env
->regs
[13] & 7)
1532 frame_addr
= env
->regs
[13];
1533 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
1536 if (do_sigframe_return_v2(env
, frame_addr
, &frame
->uc
))
1539 unlock_user_struct(frame
, frame_addr
, 0);
1540 return env
->regs
[0];
1543 unlock_user_struct(frame
, frame_addr
, 0);
1544 force_sig(SIGSEGV
/* , current */);
1548 long do_rt_sigreturn(CPUState
*env
)
1550 if (get_osversion() >= 0x020612) {
1551 return do_rt_sigreturn_v2(env
);
1553 return do_rt_sigreturn_v1(env
);
1557 #elif defined(TARGET_SPARC)
1559 #define __SUNOS_MAXWIN 31
1561 /* This is what SunOS does, so shall I. */
1562 struct target_sigcontext
{
1563 abi_ulong sigc_onstack
; /* state to restore */
1565 abi_ulong sigc_mask
; /* sigmask to restore */
1566 abi_ulong sigc_sp
; /* stack pointer */
1567 abi_ulong sigc_pc
; /* program counter */
1568 abi_ulong sigc_npc
; /* next program counter */
1569 abi_ulong sigc_psr
; /* for condition codes etc */
1570 abi_ulong sigc_g1
; /* User uses these two registers */
1571 abi_ulong sigc_o0
; /* within the trampoline code. */
1573 /* Now comes information regarding the users window set
1574 * at the time of the signal.
1576 abi_ulong sigc_oswins
; /* outstanding windows */
1578 /* stack ptrs for each regwin buf */
1579 char *sigc_spbuf
[__SUNOS_MAXWIN
];
1581 /* Windows to restore after signal */
1583 abi_ulong locals
[8];
1585 } sigc_wbuf
[__SUNOS_MAXWIN
];
1587 /* A Sparc stack frame */
1588 struct sparc_stackf
{
1589 abi_ulong locals
[8];
1591 struct sparc_stackf
*fp
;
1592 abi_ulong callers_pc
;
1595 abi_ulong xxargs
[1];
1604 abi_ulong u_regs
[16]; /* globals and ins */
1610 unsigned long si_float_regs
[32];
1611 unsigned long si_fsr
;
1612 unsigned long si_fpqdepth
;
1614 unsigned long *insn_addr
;
1617 } qemu_siginfo_fpu_t
;
1620 struct target_signal_frame
{
1621 struct sparc_stackf ss
;
1624 abi_ulong insns
[2] __attribute__ ((aligned (8)));
1625 abi_ulong extramask
[TARGET_NSIG_WORDS
- 1];
1626 abi_ulong extra_size
; /* Should be 0 */
1627 qemu_siginfo_fpu_t fpu_state
;
1629 struct target_rt_signal_frame
{
1630 struct sparc_stackf ss
;
1635 unsigned int insns
[2];
1637 unsigned int extra_size
; /* Should be 0 */
1638 qemu_siginfo_fpu_t fpu_state
;
1652 #define UREG_FP UREG_I6
1653 #define UREG_SP UREG_O6
1655 static inline abi_ulong
get_sigframe(struct target_sigaction
*sa
,
1656 CPUState
*env
, unsigned long framesize
)
1660 sp
= env
->regwptr
[UREG_FP
];
1662 /* This is the X/Open sanctioned signal stack switching. */
1663 if (sa
->sa_flags
& TARGET_SA_ONSTACK
) {
1664 if (!on_sig_stack(sp
)
1665 && !((target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
) & 7))
1666 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
1668 return sp
- framesize
;
1672 setup___siginfo(__siginfo_t
*si
, CPUState
*env
, abi_ulong mask
)
1676 err
|= __put_user(env
->psr
, &si
->si_regs
.psr
);
1677 err
|= __put_user(env
->pc
, &si
->si_regs
.pc
);
1678 err
|= __put_user(env
->npc
, &si
->si_regs
.npc
);
1679 err
|= __put_user(env
->y
, &si
->si_regs
.y
);
1680 for (i
=0; i
< 8; i
++) {
1681 err
|= __put_user(env
->gregs
[i
], &si
->si_regs
.u_regs
[i
]);
1683 for (i
=0; i
< 8; i
++) {
1684 err
|= __put_user(env
->regwptr
[UREG_I0
+ i
], &si
->si_regs
.u_regs
[i
+8]);
1686 err
|= __put_user(mask
, &si
->si_mask
);
1692 setup_sigcontext(struct target_sigcontext
*sc
, /*struct _fpstate *fpstate,*/
1693 CPUState
*env
, unsigned long mask
)
1697 err
|= __put_user(mask
, &sc
->sigc_mask
);
1698 err
|= __put_user(env
->regwptr
[UREG_SP
], &sc
->sigc_sp
);
1699 err
|= __put_user(env
->pc
, &sc
->sigc_pc
);
1700 err
|= __put_user(env
->npc
, &sc
->sigc_npc
);
1701 err
|= __put_user(env
->psr
, &sc
->sigc_psr
);
1702 err
|= __put_user(env
->gregs
[1], &sc
->sigc_g1
);
1703 err
|= __put_user(env
->regwptr
[UREG_O0
], &sc
->sigc_o0
);
1708 #define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7)))
1710 static void setup_frame(int sig
, struct target_sigaction
*ka
,
1711 target_sigset_t
*set
, CPUState
*env
)
1714 struct target_signal_frame
*sf
;
1715 int sigframe_size
, err
, i
;
1717 /* 1. Make sure everything is clean */
1718 //synchronize_user_stack();
1720 sigframe_size
= NF_ALIGNEDSZ
;
1721 sf_addr
= get_sigframe(ka
, env
, sigframe_size
);
1723 sf
= lock_user(VERIFY_WRITE
, sf_addr
,
1724 sizeof(struct target_signal_frame
), 0);
1728 //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1730 if (invalid_frame_pointer(sf
, sigframe_size
))
1731 goto sigill_and_return
;
1733 /* 2. Save the current process state */
1734 err
= setup___siginfo(&sf
->info
, env
, set
->sig
[0]);
1735 err
|= __put_user(0, &sf
->extra_size
);
1737 //err |= save_fpu_state(regs, &sf->fpu_state);
1738 //err |= __put_user(&sf->fpu_state, &sf->fpu_save);
1740 err
|= __put_user(set
->sig
[0], &sf
->info
.si_mask
);
1741 for (i
= 0; i
< TARGET_NSIG_WORDS
- 1; i
++) {
1742 err
|= __put_user(set
->sig
[i
+ 1], &sf
->extramask
[i
]);
1745 for (i
= 0; i
< 8; i
++) {
1746 err
|= __put_user(env
->regwptr
[i
+ UREG_L0
], &sf
->ss
.locals
[i
]);
1748 for (i
= 0; i
< 8; i
++) {
1749 err
|= __put_user(env
->regwptr
[i
+ UREG_I0
], &sf
->ss
.ins
[i
]);
1754 /* 3. signal handler back-trampoline and parameters */
1755 env
->regwptr
[UREG_FP
] = sf_addr
;
1756 env
->regwptr
[UREG_I0
] = sig
;
1757 env
->regwptr
[UREG_I1
] = sf_addr
+
1758 offsetof(struct target_signal_frame
, info
);
1759 env
->regwptr
[UREG_I2
] = sf_addr
+
1760 offsetof(struct target_signal_frame
, info
);
1762 /* 4. signal handler */
1763 env
->pc
= ka
->_sa_handler
;
1764 env
->npc
= (env
->pc
+ 4);
1765 /* 5. return to kernel instructions */
1766 if (ka
->sa_restorer
)
1767 env
->regwptr
[UREG_I7
] = ka
->sa_restorer
;
1771 env
->regwptr
[UREG_I7
] = sf_addr
+
1772 offsetof(struct target_signal_frame
, insns
) - 2 * 4;
1774 /* mov __NR_sigreturn, %g1 */
1776 err
|= __put_user(val32
, &sf
->insns
[0]);
1780 err
|= __put_user(val32
, &sf
->insns
[1]);
1784 /* Flush instruction space. */
1785 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
1788 unlock_user(sf
, sf_addr
, sizeof(struct target_signal_frame
));
1792 force_sig(TARGET_SIGILL
);
1795 //fprintf(stderr, "force_sig\n");
1796 unlock_user(sf
, sf_addr
, sizeof(struct target_signal_frame
));
1797 force_sig(TARGET_SIGSEGV
);
1800 restore_fpu_state(CPUState
*env
, qemu_siginfo_fpu_t
*fpu
)
1805 if (current
->flags
& PF_USEDFPU
)
1806 regs
->psr
&= ~PSR_EF
;
1808 if (current
== last_task_used_math
) {
1809 last_task_used_math
= 0;
1810 regs
->psr
&= ~PSR_EF
;
1813 current
->used_math
= 1;
1814 current
->flags
&= ~PF_USEDFPU
;
1817 if (verify_area (VERIFY_READ
, fpu
, sizeof(*fpu
)))
1822 /* XXX: incorrect */
1823 err
= __copy_from_user(&env
->fpr
[0], &fpu
->si_float_regs
[0],
1824 (sizeof(unsigned long) * 32));
1826 err
|= __get_user(env
->fsr
, &fpu
->si_fsr
);
1828 err
|= __get_user(current
->thread
.fpqdepth
, &fpu
->si_fpqdepth
);
1829 if (current
->thread
.fpqdepth
!= 0)
1830 err
|= __copy_from_user(¤t
->thread
.fpqueue
[0],
1831 &fpu
->si_fpqueue
[0],
1832 ((sizeof(unsigned long) +
1833 (sizeof(unsigned long *)))*16));
1839 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
1840 target_siginfo_t
*info
,
1841 target_sigset_t
*set
, CPUState
*env
)
1843 fprintf(stderr
, "setup_rt_frame: not implemented\n");
1846 long do_sigreturn(CPUState
*env
)
1849 struct target_signal_frame
*sf
;
1850 uint32_t up_psr
, pc
, npc
;
1851 target_sigset_t set
;
1853 abi_ulong fpu_save_addr
;
1856 sf_addr
= env
->regwptr
[UREG_FP
];
1857 if (!lock_user_struct(VERIFY_READ
, sf
, sf_addr
, 1))
1860 fprintf(stderr
, "sigreturn\n");
1861 fprintf(stderr
, "sf: %x pc %x fp %x sp %x\n", sf
, env
->pc
, env
->regwptr
[UREG_FP
], env
->regwptr
[UREG_SP
]);
1863 //cpu_dump_state(env, stderr, fprintf, 0);
1865 /* 1. Make sure we are not getting garbage from the user */
1870 err
= __get_user(pc
, &sf
->info
.si_regs
.pc
);
1871 err
|= __get_user(npc
, &sf
->info
.si_regs
.npc
);
1876 /* 2. Restore the state */
1877 err
|= __get_user(up_psr
, &sf
->info
.si_regs
.psr
);
1879 /* User can only change condition codes and FPU enabling in %psr. */
1880 env
->psr
= (up_psr
& (PSR_ICC
/* | PSR_EF */))
1881 | (env
->psr
& ~(PSR_ICC
/* | PSR_EF */));
1885 err
|= __get_user(env
->y
, &sf
->info
.si_regs
.y
);
1886 for (i
=0; i
< 8; i
++) {
1887 err
|= __get_user(env
->gregs
[i
], &sf
->info
.si_regs
.u_regs
[i
]);
1889 for (i
=0; i
< 8; i
++) {
1890 err
|= __get_user(env
->regwptr
[i
+ UREG_I0
], &sf
->info
.si_regs
.u_regs
[i
+8]);
1893 err
|= __get_user(fpu_save_addr
, &sf
->fpu_save
);
1896 // err |= restore_fpu_state(env, fpu_save);
1898 /* This is pretty much atomic, no amount locking would prevent
1899 * the races which exist anyways.
1901 err
|= __get_user(set
.sig
[0], &sf
->info
.si_mask
);
1902 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
1903 err
|= (__get_user(set
.sig
[i
], &sf
->extramask
[i
- 1]));
1906 target_to_host_sigset_internal(&host_set
, &set
);
1907 sigprocmask(SIG_SETMASK
, &host_set
, NULL
);
1911 unlock_user_struct(sf
, sf_addr
, 0);
1912 return env
->regwptr
[0];
1915 unlock_user_struct(sf
, sf_addr
, 0);
1916 force_sig(TARGET_SIGSEGV
);
1919 long do_rt_sigreturn(CPUState
*env
)
1921 fprintf(stderr
, "do_rt_sigreturn: not implemented\n");
1922 return -TARGET_ENOSYS
;
1925 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
1947 typedef abi_ulong target_mc_greg_t
;
1948 typedef target_mc_greg_t target_mc_gregset_t
[MC_NGREG
];
1950 struct target_mc_fq
{
1951 abi_ulong
*mcfq_addr
;
1955 struct target_mc_fpu
{
1959 //uint128_t qregs[16];
1961 abi_ulong mcfpu_fsr
;
1962 abi_ulong mcfpu_fprs
;
1963 abi_ulong mcfpu_gsr
;
1964 struct target_mc_fq
*mcfpu_fq
;
1965 unsigned char mcfpu_qcnt
;
1966 unsigned char mcfpu_qentsz
;
1967 unsigned char mcfpu_enab
;
1969 typedef struct target_mc_fpu target_mc_fpu_t
;
1972 target_mc_gregset_t mc_gregs
;
1973 target_mc_greg_t mc_fp
;
1974 target_mc_greg_t mc_i7
;
1975 target_mc_fpu_t mc_fpregs
;
1976 } target_mcontext_t
;
1978 struct target_ucontext
{
1979 struct target_ucontext
*uc_link
;
1981 target_sigset_t uc_sigmask
;
1982 target_mcontext_t uc_mcontext
;
1985 /* A V9 register window */
1986 struct target_reg_window
{
1987 abi_ulong locals
[8];
1991 #define TARGET_STACK_BIAS 2047
1993 /* {set, get}context() needed for 64-bit SparcLinux userland. */
1994 void sparc64_set_context(CPUSPARCState
*env
)
1997 struct target_ucontext
*ucp
;
1998 target_mc_gregset_t
*grp
;
1999 abi_ulong pc
, npc
, tstate
;
2000 abi_ulong fp
, i7
, w_addr
;
2001 unsigned char fenab
;
2005 ucp_addr
= env
->regwptr
[UREG_I0
];
2006 if (!lock_user_struct(VERIFY_READ
, ucp
, ucp_addr
, 1))
2008 grp
= &ucp
->uc_mcontext
.mc_gregs
;
2009 err
= __get_user(pc
, &((*grp
)[MC_PC
]));
2010 err
|= __get_user(npc
, &((*grp
)[MC_NPC
]));
2011 if (err
|| ((pc
| npc
) & 3))
2013 if (env
->regwptr
[UREG_I1
]) {
2014 target_sigset_t target_set
;
2017 if (TARGET_NSIG_WORDS
== 1) {
2018 if (__get_user(target_set
.sig
[0], &ucp
->uc_sigmask
.sig
[0]))
2021 abi_ulong
*src
, *dst
;
2022 src
= ucp
->uc_sigmask
.sig
;
2023 dst
= target_set
.sig
;
2024 for (i
= 0; i
< sizeof(target_sigset_t
) / sizeof(abi_ulong
);
2026 err
|= __get_user(*dst
, src
);
2030 target_to_host_sigset_internal(&set
, &target_set
);
2031 sigprocmask(SIG_SETMASK
, &set
, NULL
);
2035 err
|= __get_user(env
->y
, &((*grp
)[MC_Y
]));
2036 err
|= __get_user(tstate
, &((*grp
)[MC_TSTATE
]));
2037 env
->asi
= (tstate
>> 24) & 0xff;
2038 PUT_CCR(env
, tstate
>> 32);
2039 PUT_CWP64(env
, tstate
& 0x1f);
2040 err
|= __get_user(env
->gregs
[1], (&(*grp
)[MC_G1
]));
2041 err
|= __get_user(env
->gregs
[2], (&(*grp
)[MC_G2
]));
2042 err
|= __get_user(env
->gregs
[3], (&(*grp
)[MC_G3
]));
2043 err
|= __get_user(env
->gregs
[4], (&(*grp
)[MC_G4
]));
2044 err
|= __get_user(env
->gregs
[5], (&(*grp
)[MC_G5
]));
2045 err
|= __get_user(env
->gregs
[6], (&(*grp
)[MC_G6
]));
2046 err
|= __get_user(env
->gregs
[7], (&(*grp
)[MC_G7
]));
2047 err
|= __get_user(env
->regwptr
[UREG_I0
], (&(*grp
)[MC_O0
]));
2048 err
|= __get_user(env
->regwptr
[UREG_I1
], (&(*grp
)[MC_O1
]));
2049 err
|= __get_user(env
->regwptr
[UREG_I2
], (&(*grp
)[MC_O2
]));
2050 err
|= __get_user(env
->regwptr
[UREG_I3
], (&(*grp
)[MC_O3
]));
2051 err
|= __get_user(env
->regwptr
[UREG_I4
], (&(*grp
)[MC_O4
]));
2052 err
|= __get_user(env
->regwptr
[UREG_I5
], (&(*grp
)[MC_O5
]));
2053 err
|= __get_user(env
->regwptr
[UREG_I6
], (&(*grp
)[MC_O6
]));
2054 err
|= __get_user(env
->regwptr
[UREG_I7
], (&(*grp
)[MC_O7
]));
2056 err
|= __get_user(fp
, &(ucp
->uc_mcontext
.mc_fp
));
2057 err
|= __get_user(i7
, &(ucp
->uc_mcontext
.mc_i7
));
2059 w_addr
= TARGET_STACK_BIAS
+env
->regwptr
[UREG_I6
];
2060 if (put_user(fp
, w_addr
+ offsetof(struct target_reg_window
, ins
[6]),
2063 if (put_user(i7
, w_addr
+ offsetof(struct target_reg_window
, ins
[7]),
2066 err
|= __get_user(fenab
, &(ucp
->uc_mcontext
.mc_fpregs
.mcfpu_enab
));
2067 err
|= __get_user(env
->fprs
, &(ucp
->uc_mcontext
.mc_fpregs
.mcfpu_fprs
));
2069 uint32_t *src
, *dst
;
2070 src
= ucp
->uc_mcontext
.mc_fpregs
.mcfpu_fregs
.sregs
;
2072 /* XXX: check that the CPU storage is the same as user context */
2073 for (i
= 0; i
< 64; i
++, dst
++, src
++)
2074 err
|= __get_user(*dst
, src
);
2076 err
|= __get_user(env
->fsr
,
2077 &(ucp
->uc_mcontext
.mc_fpregs
.mcfpu_fsr
));
2078 err
|= __get_user(env
->gsr
,
2079 &(ucp
->uc_mcontext
.mc_fpregs
.mcfpu_gsr
));
2082 unlock_user_struct(ucp
, ucp_addr
, 0);
2085 unlock_user_struct(ucp
, ucp_addr
, 0);
2089 void sparc64_get_context(CPUSPARCState
*env
)
2092 struct target_ucontext
*ucp
;
2093 target_mc_gregset_t
*grp
;
2094 target_mcontext_t
*mcp
;
2095 abi_ulong fp
, i7
, w_addr
;
2098 target_sigset_t target_set
;
2101 ucp_addr
= env
->regwptr
[UREG_I0
];
2102 if (!lock_user_struct(VERIFY_WRITE
, ucp
, ucp_addr
, 0))
2105 mcp
= &ucp
->uc_mcontext
;
2106 grp
= &mcp
->mc_gregs
;
2108 /* Skip over the trap instruction, first. */
2114 sigprocmask(0, NULL
, &set
);
2115 host_to_target_sigset_internal(&target_set
, &set
);
2116 if (TARGET_NSIG_WORDS
== 1) {
2117 err
|= __put_user(target_set
.sig
[0],
2118 (abi_ulong
*)&ucp
->uc_sigmask
);
2120 abi_ulong
*src
, *dst
;
2121 src
= target_set
.sig
;
2122 dst
= ucp
->uc_sigmask
.sig
;
2123 for (i
= 0; i
< sizeof(target_sigset_t
) / sizeof(abi_ulong
);
2125 err
|= __put_user(*src
, dst
);
2130 /* XXX: tstate must be saved properly */
2131 // err |= __put_user(env->tstate, &((*grp)[MC_TSTATE]));
2132 err
|= __put_user(env
->pc
, &((*grp
)[MC_PC
]));
2133 err
|= __put_user(env
->npc
, &((*grp
)[MC_NPC
]));
2134 err
|= __put_user(env
->y
, &((*grp
)[MC_Y
]));
2135 err
|= __put_user(env
->gregs
[1], &((*grp
)[MC_G1
]));
2136 err
|= __put_user(env
->gregs
[2], &((*grp
)[MC_G2
]));
2137 err
|= __put_user(env
->gregs
[3], &((*grp
)[MC_G3
]));
2138 err
|= __put_user(env
->gregs
[4], &((*grp
)[MC_G4
]));
2139 err
|= __put_user(env
->gregs
[5], &((*grp
)[MC_G5
]));
2140 err
|= __put_user(env
->gregs
[6], &((*grp
)[MC_G6
]));
2141 err
|= __put_user(env
->gregs
[7], &((*grp
)[MC_G7
]));
2142 err
|= __put_user(env
->regwptr
[UREG_I0
], &((*grp
)[MC_O0
]));
2143 err
|= __put_user(env
->regwptr
[UREG_I1
], &((*grp
)[MC_O1
]));
2144 err
|= __put_user(env
->regwptr
[UREG_I2
], &((*grp
)[MC_O2
]));
2145 err
|= __put_user(env
->regwptr
[UREG_I3
], &((*grp
)[MC_O3
]));
2146 err
|= __put_user(env
->regwptr
[UREG_I4
], &((*grp
)[MC_O4
]));
2147 err
|= __put_user(env
->regwptr
[UREG_I5
], &((*grp
)[MC_O5
]));
2148 err
|= __put_user(env
->regwptr
[UREG_I6
], &((*grp
)[MC_O6
]));
2149 err
|= __put_user(env
->regwptr
[UREG_I7
], &((*grp
)[MC_O7
]));
2151 w_addr
= TARGET_STACK_BIAS
+env
->regwptr
[UREG_I6
];
2153 if (get_user(fp
, w_addr
+ offsetof(struct target_reg_window
, ins
[6]),
2156 if (get_user(i7
, w_addr
+ offsetof(struct target_reg_window
, ins
[7]),
2159 err
|= __put_user(fp
, &(mcp
->mc_fp
));
2160 err
|= __put_user(i7
, &(mcp
->mc_i7
));
2163 uint32_t *src
, *dst
;
2165 dst
= ucp
->uc_mcontext
.mc_fpregs
.mcfpu_fregs
.sregs
;
2166 /* XXX: check that the CPU storage is the same as user context */
2167 for (i
= 0; i
< 64; i
++, dst
++, src
++)
2168 err
|= __put_user(*src
, dst
);
2170 err
|= __put_user(env
->fsr
, &(mcp
->mc_fpregs
.mcfpu_fsr
));
2171 err
|= __put_user(env
->gsr
, &(mcp
->mc_fpregs
.mcfpu_gsr
));
2172 err
|= __put_user(env
->fprs
, &(mcp
->mc_fpregs
.mcfpu_fprs
));
2176 unlock_user_struct(ucp
, ucp_addr
, 1);
2179 unlock_user_struct(ucp
, ucp_addr
, 1);
2183 #elif defined(TARGET_ABI_MIPSN64)
2185 # warning signal handling not implemented
2187 static void setup_frame(int sig
, struct target_sigaction
*ka
,
2188 target_sigset_t
*set
, CPUState
*env
)
2190 fprintf(stderr
, "setup_frame: not implemented\n");
2193 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
2194 target_siginfo_t
*info
,
2195 target_sigset_t
*set
, CPUState
*env
)
2197 fprintf(stderr
, "setup_rt_frame: not implemented\n");
2200 long do_sigreturn(CPUState
*env
)
2202 fprintf(stderr
, "do_sigreturn: not implemented\n");
2203 return -TARGET_ENOSYS
;
2206 long do_rt_sigreturn(CPUState
*env
)
2208 fprintf(stderr
, "do_rt_sigreturn: not implemented\n");
2209 return -TARGET_ENOSYS
;
2212 #elif defined(TARGET_ABI_MIPSN32)
2214 # warning signal handling not implemented
2216 static void setup_frame(int sig
, struct target_sigaction
*ka
,
2217 target_sigset_t
*set
, CPUState
*env
)
2219 fprintf(stderr
, "setup_frame: not implemented\n");
2222 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
2223 target_siginfo_t
*info
,
2224 target_sigset_t
*set
, CPUState
*env
)
2226 fprintf(stderr
, "setup_rt_frame: not implemented\n");
2229 long do_sigreturn(CPUState
*env
)
2231 fprintf(stderr
, "do_sigreturn: not implemented\n");
2232 return -TARGET_ENOSYS
;
2235 long do_rt_sigreturn(CPUState
*env
)
2237 fprintf(stderr
, "do_rt_sigreturn: not implemented\n");
2238 return -TARGET_ENOSYS
;
2241 #elif defined(TARGET_ABI_MIPSO32)
2243 struct target_sigcontext
{
2244 uint32_t sc_regmask
; /* Unused */
2247 uint64_t sc_regs
[32];
2248 uint64_t sc_fpregs
[32];
2249 uint32_t sc_ownedfp
; /* Unused */
2250 uint32_t sc_fpc_csr
;
2251 uint32_t sc_fpc_eir
; /* Unused */
2252 uint32_t sc_used_math
;
2253 uint32_t sc_dsp
; /* dsp status, was sc_ssflags */
2256 target_ulong sc_hi1
; /* Was sc_cause */
2257 target_ulong sc_lo1
; /* Was sc_badvaddr */
2258 target_ulong sc_hi2
; /* Was sc_sigset[4] */
2259 target_ulong sc_lo2
;
2260 target_ulong sc_hi3
;
2261 target_ulong sc_lo3
;
2265 uint32_t sf_ass
[4]; /* argument save space for o32 */
2266 uint32_t sf_code
[2]; /* signal trampoline */
2267 struct target_sigcontext sf_sc
;
2268 target_sigset_t sf_mask
;
2271 /* Install trampoline to jump back from signal handler */
2272 static inline int install_sigtramp(unsigned int *tramp
, unsigned int syscall
)
2277 * Set up the return code ...
2279 * li v0, __NR__foo_sigreturn
2283 err
= __put_user(0x24020000 + syscall
, tramp
+ 0);
2284 err
|= __put_user(0x0000000c , tramp
+ 1);
2285 /* flush_cache_sigtramp((unsigned long) tramp); */
2290 setup_sigcontext(CPUState
*regs
, struct target_sigcontext
*sc
)
2294 err
|= __put_user(regs
->active_tc
.PC
, &sc
->sc_pc
);
2296 #define save_gp_reg(i) do { \
2297 err |= __put_user(regs->active_tc.gpr[i], &sc->sc_regs[i]); \
2299 __put_user(0, &sc
->sc_regs
[0]); save_gp_reg(1); save_gp_reg(2);
2300 save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
2301 save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
2302 save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
2303 save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
2304 save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
2305 save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
2306 save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
2310 err
|= __put_user(regs
->active_tc
.HI
[0], &sc
->sc_mdhi
);
2311 err
|= __put_user(regs
->active_tc
.LO
[0], &sc
->sc_mdlo
);
2313 /* Not used yet, but might be useful if we ever have DSP suppport */
2316 err
|= __put_user(mfhi1(), &sc
->sc_hi1
);
2317 err
|= __put_user(mflo1(), &sc
->sc_lo1
);
2318 err
|= __put_user(mfhi2(), &sc
->sc_hi2
);
2319 err
|= __put_user(mflo2(), &sc
->sc_lo2
);
2320 err
|= __put_user(mfhi3(), &sc
->sc_hi3
);
2321 err
|= __put_user(mflo3(), &sc
->sc_lo3
);
2322 err
|= __put_user(rddsp(DSP_MASK
), &sc
->sc_dsp
);
2324 /* same with 64 bit */
2326 err
|= __put_user(regs
->hi
, &sc
->sc_hi
[0]);
2327 err
|= __put_user(regs
->lo
, &sc
->sc_lo
[0]);
2329 err
|= __put_user(mfhi1(), &sc
->sc_hi
[1]);
2330 err
|= __put_user(mflo1(), &sc
->sc_lo
[1]);
2331 err
|= __put_user(mfhi2(), &sc
->sc_hi
[2]);
2332 err
|= __put_user(mflo2(), &sc
->sc_lo
[2]);
2333 err
|= __put_user(mfhi3(), &sc
->sc_hi
[3]);
2334 err
|= __put_user(mflo3(), &sc
->sc_lo
[3]);
2335 err
|= __put_user(rddsp(DSP_MASK
), &sc
->sc_dsp
);
2341 err
|= __put_user(!!used_math(), &sc
->sc_used_math
);
2347 * Save FPU state to signal context. Signal handler will "inherit"
2348 * current FPU state.
2352 if (!is_fpu_owner()) {
2354 restore_fp(current
);
2356 err
|= save_fp_context(sc
);
2365 restore_sigcontext(CPUState
*regs
, struct target_sigcontext
*sc
)
2369 err
|= __get_user(regs
->CP0_EPC
, &sc
->sc_pc
);
2371 err
|= __get_user(regs
->active_tc
.HI
[0], &sc
->sc_mdhi
);
2372 err
|= __get_user(regs
->active_tc
.LO
[0], &sc
->sc_mdlo
);
2374 #define restore_gp_reg(i) do { \
2375 err |= __get_user(regs->active_tc.gpr[i], &sc->sc_regs[i]); \
2377 restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
2378 restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
2379 restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
2380 restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
2381 restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
2382 restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
2383 restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
2384 restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
2385 restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
2386 restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
2388 #undef restore_gp_reg
2392 err
|= __get_user(treg
, &sc
->sc_hi1
); mthi1(treg
);
2393 err
|= __get_user(treg
, &sc
->sc_lo1
); mtlo1(treg
);
2394 err
|= __get_user(treg
, &sc
->sc_hi2
); mthi2(treg
);
2395 err
|= __get_user(treg
, &sc
->sc_lo2
); mtlo2(treg
);
2396 err
|= __get_user(treg
, &sc
->sc_hi3
); mthi3(treg
);
2397 err
|= __get_user(treg
, &sc
->sc_lo3
); mtlo3(treg
);
2398 err
|= __get_user(treg
, &sc
->sc_dsp
); wrdsp(treg
, DSP_MASK
);
2401 err
|= __get_user(regs
->hi
, &sc
->sc_hi
[0]);
2402 err
|= __get_user(regs
->lo
, &sc
->sc_lo
[0]);
2404 err
|= __get_user(treg
, &sc
->sc_hi
[1]); mthi1(treg
);
2405 err
|= __get_user(treg
, &sc
->sc_lo
[1]); mthi1(treg
);
2406 err
|= __get_user(treg
, &sc
->sc_hi
[2]); mthi2(treg
);
2407 err
|= __get_user(treg
, &sc
->sc_lo
[2]); mthi2(treg
);
2408 err
|= __get_user(treg
, &sc
->sc_hi
[3]); mthi3(treg
);
2409 err
|= __get_user(treg
, &sc
->sc_lo
[3]); mthi3(treg
);
2410 err
|= __get_user(treg
, &sc
->sc_dsp
); wrdsp(treg
, DSP_MASK
);
2414 err
|= __get_user(used_math
, &sc
->sc_used_math
);
2415 conditional_used_math(used_math
);
2420 /* restore fpu context if we have used it before */
2422 err
|= restore_fp_context(sc
);
2424 /* signal handler may have used FPU. Give it up. */
2433 * Determine which stack to use..
2435 static inline abi_ulong
2436 get_sigframe(struct target_sigaction
*ka
, CPUState
*regs
, size_t frame_size
)
2440 /* Default to using normal stack */
2441 sp
= regs
->active_tc
.gpr
[29];
2444 * FPU emulator may have it's own trampoline active just
2445 * above the user stack, 16-bytes before the next lowest
2446 * 16 byte boundary. Try to avoid trashing it.
2450 /* This is the X/Open sanctioned signal stack switching. */
2451 if ((ka
->sa_flags
& TARGET_SA_ONSTACK
) && (sas_ss_flags (sp
) == 0)) {
2452 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
2455 return (sp
- frame_size
) & ~7;
2458 /* compare linux/arch/mips/kernel/signal.c:setup_frame() */
2459 static void setup_frame(int sig
, struct target_sigaction
* ka
,
2460 target_sigset_t
*set
, CPUState
*regs
)
2462 struct sigframe
*frame
;
2463 abi_ulong frame_addr
;
2466 frame_addr
= get_sigframe(ka
, regs
, sizeof(*frame
));
2467 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
2470 install_sigtramp(frame
->sf_code
, TARGET_NR_sigreturn
);
2472 if(setup_sigcontext(regs
, &frame
->sf_sc
))
2475 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
2476 if(__put_user(set
->sig
[i
], &frame
->sf_mask
.sig
[i
]))
2481 * Arguments to signal handler:
2483 * a0 = signal number
2484 * a1 = 0 (should be cause)
2485 * a2 = pointer to struct sigcontext
2487 * $25 and PC point to the signal handler, $29 points to the
2490 regs
->active_tc
.gpr
[ 4] = sig
;
2491 regs
->active_tc
.gpr
[ 5] = 0;
2492 regs
->active_tc
.gpr
[ 6] = frame_addr
+ offsetof(struct sigframe
, sf_sc
);
2493 regs
->active_tc
.gpr
[29] = frame_addr
;
2494 regs
->active_tc
.gpr
[31] = frame_addr
+ offsetof(struct sigframe
, sf_code
);
2495 /* The original kernel code sets CP0_EPC to the handler
2496 * since it returns to userland using eret
2497 * we cannot do this here, and we must set PC directly */
2498 regs
->active_tc
.PC
= regs
->active_tc
.gpr
[25] = ka
->_sa_handler
;
2499 unlock_user_struct(frame
, frame_addr
, 1);
2503 unlock_user_struct(frame
, frame_addr
, 1);
2504 force_sig(TARGET_SIGSEGV
/*, current*/);
2508 long do_sigreturn(CPUState
*regs
)
2510 struct sigframe
*frame
;
2511 abi_ulong frame_addr
;
2513 target_sigset_t target_set
;
2516 #if defined(DEBUG_SIGNAL)
2517 fprintf(stderr
, "do_sigreturn\n");
2519 frame_addr
= regs
->active_tc
.gpr
[29];
2520 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
2523 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
2524 if(__get_user(target_set
.sig
[i
], &frame
->sf_mask
.sig
[i
]))
2528 target_to_host_sigset_internal(&blocked
, &target_set
);
2529 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
2531 if (restore_sigcontext(regs
, &frame
->sf_sc
))
2536 * Don't let your children do this ...
2538 __asm__
__volatile__(
2546 regs
->active_tc
.PC
= regs
->CP0_EPC
;
2547 /* I am not sure this is right, but it seems to work
2548 * maybe a problem with nested signals ? */
2553 force_sig(TARGET_SIGSEGV
/*, current*/);
2557 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
2558 target_siginfo_t
*info
,
2559 target_sigset_t
*set
, CPUState
*env
)
2561 fprintf(stderr
, "setup_rt_frame: not implemented\n");
2564 long do_rt_sigreturn(CPUState
*env
)
2566 fprintf(stderr
, "do_rt_sigreturn: not implemented\n");
2567 return -TARGET_ENOSYS
;
2570 #elif defined(TARGET_SH4)
2573 * code and data structures from linux kernel:
2574 * include/asm-sh/sigcontext.h
2575 * arch/sh/kernel/signal.c
2578 struct target_sigcontext
{
2579 target_ulong oldmask
;
2582 target_ulong sc_gregs
[16];
2586 target_ulong sc_gbr
;
2587 target_ulong sc_mach
;
2588 target_ulong sc_macl
;
2591 target_ulong sc_fpregs
[16];
2592 target_ulong sc_xfpregs
[16];
2593 unsigned int sc_fpscr
;
2594 unsigned int sc_fpul
;
2595 unsigned int sc_ownedfp
;
2598 struct target_sigframe
2600 struct target_sigcontext sc
;
2601 target_ulong extramask
[TARGET_NSIG_WORDS
-1];
2602 uint16_t retcode
[3];
2606 struct target_ucontext
{
2607 target_ulong uc_flags
;
2608 struct target_ucontext
*uc_link
;
2609 target_stack_t uc_stack
;
2610 struct target_sigcontext uc_mcontext
;
2611 target_sigset_t uc_sigmask
; /* mask last for extensibility */
2614 struct target_rt_sigframe
2616 struct target_siginfo info
;
2617 struct target_ucontext uc
;
2618 uint16_t retcode
[3];
2622 #define MOVW(n) (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */
2623 #define TRAP_NOARG 0xc310 /* Syscall w/no args (NR in R3) SH3/4 */
2625 static abi_ulong
get_sigframe(struct target_sigaction
*ka
,
2626 unsigned long sp
, size_t frame_size
)
2628 if ((ka
->sa_flags
& TARGET_SA_ONSTACK
) && (sas_ss_flags(sp
) == 0)) {
2629 sp
= target_sigaltstack_used
.ss_sp
+ target_sigaltstack_used
.ss_size
;
2632 return (sp
- frame_size
) & -8ul;
2635 static int setup_sigcontext(struct target_sigcontext
*sc
,
2636 CPUState
*regs
, unsigned long mask
)
2640 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
2641 COPY(gregs
[0]); COPY(gregs
[1]);
2642 COPY(gregs
[2]); COPY(gregs
[3]);
2643 COPY(gregs
[4]); COPY(gregs
[5]);
2644 COPY(gregs
[6]); COPY(gregs
[7]);
2645 COPY(gregs
[8]); COPY(gregs
[9]);
2646 COPY(gregs
[10]); COPY(gregs
[11]);
2647 COPY(gregs
[12]); COPY(gregs
[13]);
2648 COPY(gregs
[14]); COPY(gregs
[15]);
2649 COPY(gbr
); COPY(mach
);
2650 COPY(macl
); COPY(pr
);
2654 /* todo: save FPU registers here */
2656 /* non-iBCS2 extensions.. */
2657 err
|= __put_user(mask
, &sc
->oldmask
);
2662 static int restore_sigcontext(struct CPUState
*regs
,
2663 struct target_sigcontext
*sc
)
2665 unsigned int err
= 0;
2667 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
2669 COPY(gregs
[2]); COPY(gregs
[3]);
2670 COPY(gregs
[4]); COPY(gregs
[5]);
2671 COPY(gregs
[6]); COPY(gregs
[7]);
2672 COPY(gregs
[8]); COPY(gregs
[9]);
2673 COPY(gregs
[10]); COPY(gregs
[11]);
2674 COPY(gregs
[12]); COPY(gregs
[13]);
2675 COPY(gregs
[14]); COPY(gregs
[15]);
2676 COPY(gbr
); COPY(mach
);
2677 COPY(macl
); COPY(pr
);
2681 /* todo: restore FPU registers here */
2683 regs
->tra
= -1; /* disable syscall checks */
2687 static void setup_frame(int sig
, struct target_sigaction
*ka
,
2688 target_sigset_t
*set
, CPUState
*regs
)
2690 struct target_sigframe
*frame
;
2691 abi_ulong frame_addr
;
2696 frame_addr
= get_sigframe(ka
, regs
->gregs
[15], sizeof(*frame
));
2697 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
2700 signal
= current_exec_domain_sig(sig
);
2702 err
|= setup_sigcontext(&frame
->sc
, regs
, set
->sig
[0]);
2704 for (i
= 0; i
< TARGET_NSIG_WORDS
- 1; i
++) {
2705 err
|= __put_user(set
->sig
[i
+ 1], &frame
->extramask
[i
]);
2708 /* Set up to return from userspace. If provided, use a stub
2709 already in userspace. */
2710 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
2711 regs
->pr
= (unsigned long) ka
->sa_restorer
;
2713 /* Generate return code (system call to sigreturn) */
2714 err
|= __put_user(MOVW(2), &frame
->retcode
[0]);
2715 err
|= __put_user(TRAP_NOARG
, &frame
->retcode
[1]);
2716 err
|= __put_user((TARGET_NR_sigreturn
), &frame
->retcode
[2]);
2717 regs
->pr
= (unsigned long) frame
->retcode
;
2723 /* Set up registers for signal handler */
2724 regs
->gregs
[15] = (unsigned long) frame
;
2725 regs
->gregs
[4] = signal
; /* Arg for signal handler */
2727 regs
->gregs
[6] = (unsigned long) &frame
->sc
;
2728 regs
->pc
= (unsigned long) ka
->_sa_handler
;
2730 unlock_user_struct(frame
, frame_addr
, 1);
2734 unlock_user_struct(frame
, frame_addr
, 1);
2738 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
2739 target_siginfo_t
*info
,
2740 target_sigset_t
*set
, CPUState
*regs
)
2742 struct target_rt_sigframe
*frame
;
2743 abi_ulong frame_addr
;
2748 frame_addr
= get_sigframe(ka
, regs
->gregs
[15], sizeof(*frame
));
2749 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
2752 signal
= current_exec_domain_sig(sig
);
2754 err
|= copy_siginfo_to_user(&frame
->info
, info
);
2756 /* Create the ucontext. */
2757 err
|= __put_user(0, &frame
->uc
.uc_flags
);
2758 err
|= __put_user(0, (unsigned long *)&frame
->uc
.uc_link
);
2759 err
|= __put_user((unsigned long)target_sigaltstack_used
.ss_sp
,
2760 &frame
->uc
.uc_stack
.ss_sp
);
2761 err
|= __put_user(sas_ss_flags(regs
->gregs
[15]),
2762 &frame
->uc
.uc_stack
.ss_flags
);
2763 err
|= __put_user(target_sigaltstack_used
.ss_size
,
2764 &frame
->uc
.uc_stack
.ss_size
);
2765 err
|= setup_sigcontext(&frame
->uc
.uc_mcontext
,
2767 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
2768 err
|= __put_user(set
->sig
[i
], &frame
->uc
.uc_sigmask
.sig
[i
]);
2771 /* Set up to return from userspace. If provided, use a stub
2772 already in userspace. */
2773 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
2774 regs
->pr
= (unsigned long) ka
->sa_restorer
;
2776 /* Generate return code (system call to sigreturn) */
2777 err
|= __put_user(MOVW(2), &frame
->retcode
[0]);
2778 err
|= __put_user(TRAP_NOARG
, &frame
->retcode
[1]);
2779 err
|= __put_user((TARGET_NR_rt_sigreturn
), &frame
->retcode
[2]);
2780 regs
->pr
= (unsigned long) frame
->retcode
;
2786 /* Set up registers for signal handler */
2787 regs
->gregs
[15] = (unsigned long) frame
;
2788 regs
->gregs
[4] = signal
; /* Arg for signal handler */
2789 regs
->gregs
[5] = (unsigned long) &frame
->info
;
2790 regs
->gregs
[6] = (unsigned long) &frame
->uc
;
2791 regs
->pc
= (unsigned long) ka
->_sa_handler
;
2793 unlock_user_struct(frame
, frame_addr
, 1);
2797 unlock_user_struct(frame
, frame_addr
, 1);
2801 long do_sigreturn(CPUState
*regs
)
2803 struct target_sigframe
*frame
;
2804 abi_ulong frame_addr
;
2806 target_sigset_t target_set
;
2810 #if defined(DEBUG_SIGNAL)
2811 fprintf(stderr
, "do_sigreturn\n");
2813 frame_addr
= regs
->gregs
[15];
2814 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
2817 err
|= __get_user(target_set
.sig
[0], &frame
->sc
.oldmask
);
2818 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
2819 err
|= (__get_user(target_set
.sig
[i
], &frame
->extramask
[i
- 1]));
2825 target_to_host_sigset_internal(&blocked
, &target_set
);
2826 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
2828 if (restore_sigcontext(regs
, &frame
->sc
))
2831 unlock_user_struct(frame
, frame_addr
, 0);
2832 return regs
->gregs
[0];
2835 unlock_user_struct(frame
, frame_addr
, 0);
2836 force_sig(TARGET_SIGSEGV
);
2840 long do_rt_sigreturn(CPUState
*regs
)
2842 struct target_rt_sigframe
*frame
;
2843 abi_ulong frame_addr
;
2846 #if defined(DEBUG_SIGNAL)
2847 fprintf(stderr
, "do_rt_sigreturn\n");
2849 frame_addr
= regs
->gregs
[15];
2850 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
2853 target_to_host_sigset(&blocked
, &frame
->uc
.uc_sigmask
);
2854 sigprocmask(SIG_SETMASK
, &blocked
, NULL
);
2856 if (restore_sigcontext(regs
, &frame
->uc
.uc_mcontext
))
2859 if (do_sigaltstack(frame_addr
+
2860 offsetof(struct target_rt_sigframe
, uc
.uc_stack
),
2861 0, get_sp_from_cpustate(regs
)) == -EFAULT
)
2864 unlock_user_struct(frame
, frame_addr
, 0);
2865 return regs
->gregs
[0];
2868 unlock_user_struct(frame
, frame_addr
, 0);
2869 force_sig(TARGET_SIGSEGV
);
2872 #elif defined(TARGET_CRIS)
2874 struct target_sigcontext
{
2875 struct target_pt_regs regs
; /* needs to be first */
2877 uint32_t usp
; /* usp before stacking this gunk on it */
2880 /* Signal frames. */
2881 struct target_signal_frame
{
2882 struct target_sigcontext sc
;
2883 uint32_t extramask
[TARGET_NSIG_WORDS
- 1];
2884 uint8_t retcode
[8]; /* Trampoline code. */
2887 struct rt_signal_frame
{
2888 struct siginfo
*pinfo
;
2890 struct siginfo info
;
2892 uint8_t retcode
[8]; /* Trampoline code. */
2895 static void setup_sigcontext(struct target_sigcontext
*sc
, CPUState
*env
)
2897 __put_user(env
->regs
[0], &sc
->regs
.r0
);
2898 __put_user(env
->regs
[1], &sc
->regs
.r1
);
2899 __put_user(env
->regs
[2], &sc
->regs
.r2
);
2900 __put_user(env
->regs
[3], &sc
->regs
.r3
);
2901 __put_user(env
->regs
[4], &sc
->regs
.r4
);
2902 __put_user(env
->regs
[5], &sc
->regs
.r5
);
2903 __put_user(env
->regs
[6], &sc
->regs
.r6
);
2904 __put_user(env
->regs
[7], &sc
->regs
.r7
);
2905 __put_user(env
->regs
[8], &sc
->regs
.r8
);
2906 __put_user(env
->regs
[9], &sc
->regs
.r9
);
2907 __put_user(env
->regs
[10], &sc
->regs
.r10
);
2908 __put_user(env
->regs
[11], &sc
->regs
.r11
);
2909 __put_user(env
->regs
[12], &sc
->regs
.r12
);
2910 __put_user(env
->regs
[13], &sc
->regs
.r13
);
2911 __put_user(env
->regs
[14], &sc
->usp
);
2912 __put_user(env
->regs
[15], &sc
->regs
.acr
);
2913 __put_user(env
->pregs
[PR_MOF
], &sc
->regs
.mof
);
2914 __put_user(env
->pregs
[PR_SRP
], &sc
->regs
.srp
);
2915 __put_user(env
->pc
, &sc
->regs
.erp
);
2918 static void restore_sigcontext(struct target_sigcontext
*sc
, CPUState
*env
)
2920 __get_user(env
->regs
[0], &sc
->regs
.r0
);
2921 __get_user(env
->regs
[1], &sc
->regs
.r1
);
2922 __get_user(env
->regs
[2], &sc
->regs
.r2
);
2923 __get_user(env
->regs
[3], &sc
->regs
.r3
);
2924 __get_user(env
->regs
[4], &sc
->regs
.r4
);
2925 __get_user(env
->regs
[5], &sc
->regs
.r5
);
2926 __get_user(env
->regs
[6], &sc
->regs
.r6
);
2927 __get_user(env
->regs
[7], &sc
->regs
.r7
);
2928 __get_user(env
->regs
[8], &sc
->regs
.r8
);
2929 __get_user(env
->regs
[9], &sc
->regs
.r9
);
2930 __get_user(env
->regs
[10], &sc
->regs
.r10
);
2931 __get_user(env
->regs
[11], &sc
->regs
.r11
);
2932 __get_user(env
->regs
[12], &sc
->regs
.r12
);
2933 __get_user(env
->regs
[13], &sc
->regs
.r13
);
2934 __get_user(env
->regs
[14], &sc
->usp
);
2935 __get_user(env
->regs
[15], &sc
->regs
.acr
);
2936 __get_user(env
->pregs
[PR_MOF
], &sc
->regs
.mof
);
2937 __get_user(env
->pregs
[PR_SRP
], &sc
->regs
.srp
);
2938 __get_user(env
->pc
, &sc
->regs
.erp
);
2941 static abi_ulong
get_sigframe(CPUState
*env
, int framesize
)
2944 /* Align the stack downwards to 4. */
2945 sp
= (env
->regs
[R_SP
] & ~3);
2946 return sp
- framesize
;
2949 static void setup_frame(int sig
, struct target_sigaction
*ka
,
2950 target_sigset_t
*set
, CPUState
*env
)
2952 struct target_signal_frame
*frame
;
2953 abi_ulong frame_addr
;
2957 frame_addr
= get_sigframe(env
, sizeof *frame
);
2958 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
2962 * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't
2963 * use this trampoline anymore but it sets it up for GDB.
2964 * In QEMU, using the trampoline simplifies things a bit so we use it.
2966 * This is movu.w __NR_sigreturn, r9; break 13;
2968 err
|= __put_user(0x9c5f, frame
->retcode
+0);
2969 err
|= __put_user(TARGET_NR_sigreturn
,
2971 err
|= __put_user(0xe93d, frame
->retcode
+4);
2973 /* Save the mask. */
2974 err
|= __put_user(set
->sig
[0], &frame
->sc
.oldmask
);
2978 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
2979 if (__put_user(set
->sig
[i
], &frame
->extramask
[i
- 1]))
2983 setup_sigcontext(&frame
->sc
, env
);
2985 /* Move the stack and setup the arguments for the handler. */
2986 env
->regs
[R_SP
] = (uint32_t) (unsigned long) frame
;
2987 env
->regs
[10] = sig
;
2988 env
->pc
= (unsigned long) ka
->_sa_handler
;
2989 /* Link SRP so the guest returns through the trampoline. */
2990 env
->pregs
[PR_SRP
] = (uint32_t) (unsigned long) &frame
->retcode
[0];
2992 unlock_user_struct(frame
, frame_addr
, 1);
2995 unlock_user_struct(frame
, frame_addr
, 1);
2996 force_sig(TARGET_SIGSEGV
);
2999 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
3000 target_siginfo_t
*info
,
3001 target_sigset_t
*set
, CPUState
*env
)
3003 fprintf(stderr
, "CRIS setup_rt_frame: not implemented\n");
3006 long do_sigreturn(CPUState
*env
)
3008 struct target_signal_frame
*frame
;
3009 abi_ulong frame_addr
;
3010 target_sigset_t target_set
;
3014 frame_addr
= env
->regs
[R_SP
];
3015 /* Make sure the guest isn't playing games. */
3016 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 1))
3019 /* Restore blocked signals */
3020 if (__get_user(target_set
.sig
[0], &frame
->sc
.oldmask
))
3022 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
3023 if (__get_user(target_set
.sig
[i
], &frame
->extramask
[i
- 1]))
3026 target_to_host_sigset_internal(&set
, &target_set
);
3027 sigprocmask(SIG_SETMASK
, &set
, NULL
);
3029 restore_sigcontext(&frame
->sc
, env
);
3030 /* Compensate for the syscall return path advancing brk. */
3033 unlock_user_struct(frame
, frame_addr
, 0);
3034 return env
->regs
[10];
3036 unlock_user_struct(frame
, frame_addr
, 0);
3037 force_sig(TARGET_SIGSEGV
);
3040 long do_rt_sigreturn(CPUState
*env
)
3042 fprintf(stderr
, "CRIS do_rt_sigreturn: not implemented\n");
3043 return -TARGET_ENOSYS
;
3048 static void setup_frame(int sig
, struct target_sigaction
*ka
,
3049 target_sigset_t
*set
, CPUState
*env
)
3051 fprintf(stderr
, "setup_frame: not implemented\n");
3054 static void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
3055 target_siginfo_t
*info
,
3056 target_sigset_t
*set
, CPUState
*env
)
3058 fprintf(stderr
, "setup_rt_frame: not implemented\n");
3061 long do_sigreturn(CPUState
*env
)
3063 fprintf(stderr
, "do_sigreturn: not implemented\n");
3064 return -TARGET_ENOSYS
;
3067 long do_rt_sigreturn(CPUState
*env
)
3069 fprintf(stderr
, "do_rt_sigreturn: not implemented\n");
3070 return -TARGET_ENOSYS
;
3075 void process_pending_signals(CPUState
*cpu_env
)
3079 sigset_t set
, old_set
;
3080 target_sigset_t target_old_set
;
3081 struct emulated_sigtable
*k
;
3082 struct target_sigaction
*sa
;
3084 TaskState
*ts
= cpu_env
->opaque
;
3086 if (!ts
->signal_pending
)
3089 /* FIXME: This is not threadsafe. */
3091 for(sig
= 1; sig
<= TARGET_NSIG
; sig
++) {
3096 /* if no signal is pending, just return */
3097 ts
->signal_pending
= 0;
3102 fprintf(stderr
, "qemu: process signal %d\n", sig
);
3104 /* dequeue signal */
3110 sig
= gdb_handlesig (cpu_env
, sig
);
3112 fprintf (stderr
, "Lost signal\n");
3116 sa
= &sigact_table
[sig
- 1];
3117 handler
= sa
->_sa_handler
;
3118 if (handler
== TARGET_SIG_DFL
) {
3119 /* default handler : ignore some signal. The other are fatal */
3120 if (sig
!= TARGET_SIGCHLD
&&
3121 sig
!= TARGET_SIGURG
&&
3122 sig
!= TARGET_SIGWINCH
) {
3125 } else if (handler
== TARGET_SIG_IGN
) {
3127 } else if (handler
== TARGET_SIG_ERR
) {
3130 /* compute the blocked signals during the handler execution */
3131 target_to_host_sigset(&set
, &sa
->sa_mask
);
3132 /* SA_NODEFER indicates that the current signal should not be
3133 blocked during the handler */
3134 if (!(sa
->sa_flags
& TARGET_SA_NODEFER
))
3135 sigaddset(&set
, target_to_host_signal(sig
));
3137 /* block signals in the handler using Linux */
3138 sigprocmask(SIG_BLOCK
, &set
, &old_set
);
3139 /* save the previous blocked signal state to restore it at the
3140 end of the signal execution (see do_sigreturn) */
3141 host_to_target_sigset_internal(&target_old_set
, &old_set
);
3143 /* if the CPU is in VM86 mode, we restore the 32 bit values */
3144 #if defined(TARGET_I386) && !defined(TARGET_X86_64)
3146 CPUX86State
*env
= cpu_env
;
3147 if (env
->eflags
& VM_MASK
)
3148 save_v86_state(env
);
3151 /* prepare the stack frame of the virtual CPU */
3152 if (sa
->sa_flags
& TARGET_SA_SIGINFO
)
3153 setup_rt_frame(sig
, sa
, &q
->info
, &target_old_set
, cpu_env
);
3155 setup_frame(sig
, sa
, &target_old_set
, cpu_env
);
3156 if (sa
->sa_flags
& TARGET_SA_RESETHAND
)
3157 sa
->_sa_handler
= TARGET_SIG_DFL
;
3160 free_sigqueue(cpu_env
, q
);