2 * Emulation of BSD signals
4 * Copyright (c) 2003 - 2008 Fabrice Bellard
5 * Copyright (c) 2013 Stacey Son
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, see <http://www.gnu.org/licenses/>.
21 #include "qemu/osdep.h"
24 #include "gdbstub/user.h"
25 #include "signal-common.h"
27 #include "hw/core/tcg-cpu-ops.h"
28 #include "host-signal.h"
30 static struct target_sigaction sigact_table
[TARGET_NSIG
];
31 static void host_signal_handler(int host_sig
, siginfo_t
*info
, void *puc
);
32 static void target_to_host_sigset_internal(sigset_t
*d
,
33 const target_sigset_t
*s
);
35 static inline int on_sig_stack(TaskState
*ts
, unsigned long sp
)
37 return sp
- ts
->sigaltstack_used
.ss_sp
< ts
->sigaltstack_used
.ss_size
;
40 static inline int sas_ss_flags(TaskState
*ts
, unsigned long sp
)
42 return ts
->sigaltstack_used
.ss_size
== 0 ? SS_DISABLE
:
43 on_sig_stack(ts
, sp
) ? SS_ONSTACK
: 0;
47 * The BSD ABIs use the same signal numbers across all the CPU architectures, so
48 * (unlike Linux) these functions are just the identity mapping. This might not
49 * be true for XyzBSD running on AbcBSD, which doesn't currently work.
51 int host_to_target_signal(int sig
)
56 int target_to_host_signal(int sig
)
61 static inline void target_sigemptyset(target_sigset_t
*set
)
63 memset(set
, 0, sizeof(*set
));
66 static inline void target_sigaddset(target_sigset_t
*set
, int signum
)
69 uint32_t mask
= (uint32_t)1 << (signum
% TARGET_NSIG_BPW
);
70 set
->__bits
[signum
/ TARGET_NSIG_BPW
] |= mask
;
73 static inline int target_sigismember(const target_sigset_t
*set
, int signum
)
76 abi_ulong mask
= (abi_ulong
)1 << (signum
% TARGET_NSIG_BPW
);
77 return (set
->__bits
[signum
/ TARGET_NSIG_BPW
] & mask
) != 0;
80 /* Adjust the signal context to rewind out of safe-syscall if we're in it */
81 static inline void rewind_if_in_safe_syscall(void *puc
)
83 ucontext_t
*uc
= (ucontext_t
*)puc
;
84 uintptr_t pcreg
= host_signal_pc(uc
);
86 if (pcreg
> (uintptr_t)safe_syscall_start
87 && pcreg
< (uintptr_t)safe_syscall_end
) {
88 host_signal_set_pc(uc
, (uintptr_t)safe_syscall_start
);
93 * Note: The following take advantage of the BSD signal property that all
94 * signals are available on all architectures.
96 static void host_to_target_sigset_internal(target_sigset_t
*d
,
101 target_sigemptyset(d
);
102 for (i
= 1; i
<= NSIG
; i
++) {
103 if (sigismember(s
, i
)) {
104 target_sigaddset(d
, host_to_target_signal(i
));
109 void host_to_target_sigset(target_sigset_t
*d
, const sigset_t
*s
)
114 host_to_target_sigset_internal(&d1
, s
);
115 for (i
= 0; i
< _SIG_WORDS
; i
++) {
116 d
->__bits
[i
] = tswap32(d1
.__bits
[i
]);
120 static void target_to_host_sigset_internal(sigset_t
*d
,
121 const target_sigset_t
*s
)
126 for (i
= 1; i
<= TARGET_NSIG
; i
++) {
127 if (target_sigismember(s
, i
)) {
128 sigaddset(d
, target_to_host_signal(i
));
133 void target_to_host_sigset(sigset_t
*d
, const target_sigset_t
*s
)
138 for (i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
139 s1
.__bits
[i
] = tswap32(s
->__bits
[i
]);
141 target_to_host_sigset_internal(d
, &s1
);
144 static bool has_trapno(int tsig
)
146 return tsig
== TARGET_SIGILL
||
147 tsig
== TARGET_SIGFPE
||
148 tsig
== TARGET_SIGSEGV
||
149 tsig
== TARGET_SIGBUS
||
150 tsig
== TARGET_SIGTRAP
;
153 /* Siginfo conversion. */
156 * Populate tinfo w/o swapping based on guessing which fields are valid.
158 static inline void host_to_target_siginfo_noswap(target_siginfo_t
*tinfo
,
159 const siginfo_t
*info
)
161 int sig
= host_to_target_signal(info
->si_signo
);
162 int si_code
= info
->si_code
;
166 * Make sure we that the variable portion of the target siginfo is zeroed
167 * out so we don't leak anything into that.
169 memset(&tinfo
->_reason
, 0, sizeof(tinfo
->_reason
));
172 * This is awkward, because we have to use a combination of the si_code and
173 * si_signo to figure out which of the union's members are valid.o We
174 * therefore make our best guess.
176 * Once we have made our guess, we record it in the top 16 bits of
177 * the si_code, so that tswap_siginfo() later can use it.
178 * tswap_siginfo() will strip these top bits out before writing
179 * si_code to the guest (sign-extending the lower bits).
181 tinfo
->si_signo
= sig
;
182 tinfo
->si_errno
= info
->si_errno
;
183 tinfo
->si_code
= info
->si_code
;
184 tinfo
->si_pid
= info
->si_pid
;
185 tinfo
->si_uid
= info
->si_uid
;
186 tinfo
->si_status
= info
->si_status
;
187 tinfo
->si_addr
= (abi_ulong
)(unsigned long)info
->si_addr
;
189 * si_value is opaque to kernel. On all FreeBSD platforms,
190 * sizeof(sival_ptr) >= sizeof(sival_int) so the following
191 * always will copy the larger element.
193 tinfo
->si_value
.sival_ptr
=
194 (abi_ulong
)(unsigned long)info
->si_value
.sival_ptr
;
198 * All the SI_xxx codes that are defined here are global to
199 * all the signals (they have values that none of the other,
200 * more specific signal info will set).
208 * Only the fixed parts are valid (though FreeBSD doesn't always
209 * set all the fields to non-zero values.
211 si_type
= QEMU_SI_NOINFO
;
214 tinfo
->_reason
._timer
._timerid
= info
->_reason
._timer
._timerid
;
215 tinfo
->_reason
._timer
._overrun
= info
->_reason
._timer
._overrun
;
216 si_type
= QEMU_SI_TIMER
;
219 tinfo
->_reason
._mesgq
._mqd
= info
->_reason
._mesgq
._mqd
;
220 si_type
= QEMU_SI_MESGQ
;
224 * We have to go based on the signal number now to figure out
227 si_type
= QEMU_SI_NOINFO
;
228 if (has_trapno(sig
)) {
229 tinfo
->_reason
._fault
._trapno
= info
->_reason
._fault
._trapno
;
230 si_type
= QEMU_SI_FAULT
;
232 #ifdef TARGET_SIGPOLL
234 * FreeBSD never had SIGPOLL, but emulates it for Linux so there's
235 * a chance it may popup in the future.
237 if (sig
== TARGET_SIGPOLL
) {
238 tinfo
->_reason
._poll
._band
= info
->_reason
._poll
._band
;
239 si_type
= QEMU_SI_POLL
;
243 * Unsure that this can actually be generated, and our support for
244 * capsicum is somewhere between weak and non-existent, but if we get
245 * one, then we know what to save.
247 #ifdef QEMU_SI_CAPSICUM
248 if (sig
== TARGET_SIGTRAP
) {
249 tinfo
->_reason
._capsicum
._syscall
=
250 info
->_reason
._capsicum
._syscall
;
251 si_type
= QEMU_SI_CAPSICUM
;
256 tinfo
->si_code
= deposit32(si_code
, 24, 8, si_type
);
259 static void tswap_siginfo(target_siginfo_t
*tinfo
, const target_siginfo_t
*info
)
261 int si_type
= extract32(info
->si_code
, 24, 8);
262 int si_code
= sextract32(info
->si_code
, 0, 24);
264 __put_user(info
->si_signo
, &tinfo
->si_signo
);
265 __put_user(info
->si_errno
, &tinfo
->si_errno
);
266 __put_user(si_code
, &tinfo
->si_code
); /* Zero out si_type, it's internal */
267 __put_user(info
->si_pid
, &tinfo
->si_pid
);
268 __put_user(info
->si_uid
, &tinfo
->si_uid
);
269 __put_user(info
->si_status
, &tinfo
->si_status
);
270 __put_user(info
->si_addr
, &tinfo
->si_addr
);
272 * Unswapped, because we passed it through mostly untouched. si_value is
273 * opaque to the kernel, so we didn't bother with potentially wasting cycles
274 * to swap it into host byte order.
276 tinfo
->si_value
.sival_ptr
= info
->si_value
.sival_ptr
;
279 * We can use our internal marker of which fields in the structure
280 * are valid, rather than duplicating the guesswork of
281 * host_to_target_siginfo_noswap() here.
284 case QEMU_SI_NOINFO
: /* No additional info */
287 __put_user(info
->_reason
._fault
._trapno
,
288 &tinfo
->_reason
._fault
._trapno
);
291 __put_user(info
->_reason
._timer
._timerid
,
292 &tinfo
->_reason
._timer
._timerid
);
293 __put_user(info
->_reason
._timer
._overrun
,
294 &tinfo
->_reason
._timer
._overrun
);
297 __put_user(info
->_reason
._mesgq
._mqd
, &tinfo
->_reason
._mesgq
._mqd
);
300 /* Note: Not generated on FreeBSD */
301 __put_user(info
->_reason
._poll
._band
, &tinfo
->_reason
._poll
._band
);
303 #ifdef QEMU_SI_CAPSICUM
304 case QEMU_SI_CAPSICUM
:
305 __put_user(info
->_reason
._capsicum
._syscall
,
306 &tinfo
->_reason
._capsicum
._syscall
);
310 g_assert_not_reached();
314 void host_to_target_siginfo(target_siginfo_t
*tinfo
, const siginfo_t
*info
)
316 host_to_target_siginfo_noswap(tinfo
, info
);
317 tswap_siginfo(tinfo
, tinfo
);
320 int block_signals(void)
322 TaskState
*ts
= (TaskState
*)thread_cpu
->opaque
;
326 * It's OK to block everything including SIGSEGV, because we won't run any
327 * further guest code before unblocking signals in
328 * process_pending_signals(). We depend on the FreeBSD behavior here where
329 * this will only affect this thread's signal mask. We don't use
330 * pthread_sigmask which might seem more correct because that routine also
331 * does odd things with SIGCANCEL to implement pthread_cancel().
334 sigprocmask(SIG_SETMASK
, &set
, 0);
336 return qatomic_xchg(&ts
->signal_pending
, 1);
339 /* Returns 1 if given signal should dump core if not handled. */
340 static int core_dump_signal(int sig
)
356 /* Abort execution with signal. */
358 void dump_core_and_abort(int target_sig
)
360 CPUArchState
*env
= thread_cpu
->env_ptr
;
361 CPUState
*cpu
= env_cpu(env
);
362 TaskState
*ts
= cpu
->opaque
;
365 struct sigaction act
;
367 host_sig
= target_to_host_signal(target_sig
);
368 gdb_signalled(env
, target_sig
);
370 /* Dump core if supported by target binary format */
371 if (core_dump_signal(target_sig
) && (ts
->bprm
->core_dump
!= NULL
)) {
374 ((*ts
->bprm
->core_dump
)(target_sig
, env
) == 0);
377 struct rlimit nodump
;
380 * We already dumped the core of target process, we don't want
381 * a coredump of qemu itself.
383 getrlimit(RLIMIT_CORE
, &nodump
);
385 setrlimit(RLIMIT_CORE
, &nodump
);
386 (void) fprintf(stderr
, "qemu: uncaught target signal %d (%s) "
387 "- %s\n", target_sig
, strsignal(host_sig
), "core dumped");
391 * The proper exit code for dying from an uncaught signal is
392 * -<signal>. The kernel doesn't allow exit() or _exit() to pass
393 * a negative value. To get the proper exit code we need to
394 * actually die from an uncaught signal. Here the default signal
395 * handler is installed, we send ourself a signal and we wait for
398 memset(&act
, 0, sizeof(act
));
399 sigfillset(&act
.sa_mask
);
400 act
.sa_handler
= SIG_DFL
;
401 sigaction(host_sig
, &act
, NULL
);
403 kill(getpid(), host_sig
);
406 * Make sure the signal isn't masked (just reuse the mask inside
409 sigdelset(&act
.sa_mask
, host_sig
);
410 sigsuspend(&act
.sa_mask
);
417 * Queue a signal so that it will be send to the virtual CPU as soon as
420 void queue_signal(CPUArchState
*env
, int sig
, int si_type
,
421 target_siginfo_t
*info
)
423 CPUState
*cpu
= env_cpu(env
);
424 TaskState
*ts
= cpu
->opaque
;
426 trace_user_queue_signal(env
, sig
);
428 info
->si_code
= deposit32(info
->si_code
, 24, 8, si_type
);
430 ts
->sync_signal
.info
= *info
;
431 ts
->sync_signal
.pending
= sig
;
432 /* Signal that a new signal is pending. */
433 qatomic_set(&ts
->signal_pending
, 1);
437 static int fatal_signal(int sig
)
443 case TARGET_SIGWINCH
:
445 /* Ignored by default. */
452 /* Job control signals. */
460 * Force a synchronously taken QEMU_SI_FAULT signal. For QEMU the
461 * 'force' part is handled in process_pending_signals().
463 void force_sig_fault(int sig
, int code
, abi_ulong addr
)
465 CPUState
*cpu
= thread_cpu
;
466 CPUArchState
*env
= cpu
->env_ptr
;
467 target_siginfo_t info
= {};
473 queue_signal(env
, sig
, QEMU_SI_FAULT
, &info
);
476 static void host_signal_handler(int host_sig
, siginfo_t
*info
, void *puc
)
478 CPUArchState
*env
= thread_cpu
->env_ptr
;
479 CPUState
*cpu
= env_cpu(env
);
480 TaskState
*ts
= cpu
->opaque
;
481 target_siginfo_t tinfo
;
482 ucontext_t
*uc
= puc
;
483 struct emulated_sigtable
*k
;
486 bool sync_sig
= false;
489 * Non-spoofed SIGSEGV and SIGBUS are synchronous, and need special
490 * handling wrt signal blocking and unwinding.
492 if ((host_sig
== SIGSEGV
|| host_sig
== SIGBUS
) && info
->si_code
> 0) {
493 MMUAccessType access_type
;
498 host_addr
= (uintptr_t)info
->si_addr
;
501 * Convert forcefully to guest address space: addresses outside
502 * reserved_va are still valid to report via SEGV_MAPERR.
504 guest_addr
= h2g_nocheck(host_addr
);
506 pc
= host_signal_pc(uc
);
507 is_write
= host_signal_write(info
, uc
);
508 access_type
= adjust_signal_pc(&pc
, is_write
);
510 if (host_sig
== SIGSEGV
) {
513 if (info
->si_code
== SEGV_ACCERR
&& h2g_valid(host_addr
)) {
514 /* If this was a write to a TB protected page, restart. */
516 handle_sigsegv_accerr_write(cpu
, &uc
->uc_sigmask
,
522 * With reserved_va, the whole address space is PROT_NONE,
523 * which means that we may get ACCERR when we want MAPERR.
525 if (page_get_flags(guest_addr
) & PAGE_VALID
) {
528 info
->si_code
= SEGV_MAPERR
;
532 sigprocmask(SIG_SETMASK
, &uc
->uc_sigmask
, NULL
);
533 cpu_loop_exit_sigsegv(cpu
, guest_addr
, access_type
, maperr
, pc
);
535 sigprocmask(SIG_SETMASK
, &uc
->uc_sigmask
, NULL
);
536 if (info
->si_code
== BUS_ADRALN
) {
537 cpu_loop_exit_sigbus(cpu
, guest_addr
, access_type
, pc
);
544 /* Get the target signal number. */
545 guest_sig
= host_to_target_signal(host_sig
);
546 if (guest_sig
< 1 || guest_sig
> TARGET_NSIG
) {
549 trace_user_host_signal(cpu
, host_sig
, guest_sig
);
551 host_to_target_siginfo_noswap(&tinfo
, info
);
553 k
= &ts
->sigtab
[guest_sig
- 1];
555 k
->pending
= guest_sig
;
556 ts
->signal_pending
= 1;
559 * For synchronous signals, unwind the cpu state to the faulting
560 * insn and then exit back to the main loop so that the signal
561 * is delivered immediately.
564 cpu
->exception_index
= EXCP_INTERRUPT
;
565 cpu_loop_exit_restore(cpu
, pc
);
568 rewind_if_in_safe_syscall(puc
);
571 * Block host signals until target signal handler entered. We
572 * can't block SIGSEGV or SIGBUS while we're executing guest
573 * code in case the guest code provokes one in the window between
574 * now and it getting out to the main loop. Signals will be
575 * unblocked again in process_pending_signals().
577 sigfillset(&uc
->uc_sigmask
);
578 sigdelset(&uc
->uc_sigmask
, SIGSEGV
);
579 sigdelset(&uc
->uc_sigmask
, SIGBUS
);
581 /* Interrupt the virtual CPU as soon as possible. */
582 cpu_exit(thread_cpu
);
585 /* do_sigaltstack() returns target values and errnos. */
586 /* compare to kern/kern_sig.c sys_sigaltstack() and kern_sigaltstack() */
587 abi_long
do_sigaltstack(abi_ulong uss_addr
, abi_ulong uoss_addr
, abi_ulong sp
)
589 TaskState
*ts
= (TaskState
*)thread_cpu
->opaque
;
594 /* Save current signal stack params */
595 oss
.ss_sp
= tswapl(ts
->sigaltstack_used
.ss_sp
);
596 oss
.ss_size
= tswapl(ts
->sigaltstack_used
.ss_size
);
597 oss
.ss_flags
= tswapl(sas_ss_flags(ts
, sp
));
603 size_t minstacksize
= TARGET_MINSIGSTKSZ
;
605 ret
= -TARGET_EFAULT
;
606 if (!lock_user_struct(VERIFY_READ
, uss
, uss_addr
, 1)) {
609 __get_user(ss
.ss_sp
, &uss
->ss_sp
);
610 __get_user(ss
.ss_size
, &uss
->ss_size
);
611 __get_user(ss
.ss_flags
, &uss
->ss_flags
);
612 unlock_user_struct(uss
, uss_addr
, 0);
615 if (on_sig_stack(ts
, sp
)) {
619 ret
= -TARGET_EINVAL
;
620 if (ss
.ss_flags
!= TARGET_SS_DISABLE
621 && ss
.ss_flags
!= TARGET_SS_ONSTACK
622 && ss
.ss_flags
!= 0) {
626 if (ss
.ss_flags
== TARGET_SS_DISABLE
) {
630 ret
= -TARGET_ENOMEM
;
631 if (ss
.ss_size
< minstacksize
) {
636 ts
->sigaltstack_used
.ss_sp
= ss
.ss_sp
;
637 ts
->sigaltstack_used
.ss_size
= ss
.ss_size
;
641 ret
= -TARGET_EFAULT
;
642 if (copy_to_user(uoss_addr
, &oss
, sizeof(oss
))) {
652 /* do_sigaction() return host values and errnos */
653 int do_sigaction(int sig
, const struct target_sigaction
*act
,
654 struct target_sigaction
*oact
)
656 struct target_sigaction
*k
;
657 struct sigaction act1
;
661 if (sig
< 1 || sig
> TARGET_NSIG
) {
662 return -TARGET_EINVAL
;
665 if ((sig
== TARGET_SIGKILL
|| sig
== TARGET_SIGSTOP
) &&
666 act
!= NULL
&& act
->_sa_handler
!= TARGET_SIG_DFL
) {
667 return -TARGET_EINVAL
;
670 if (block_signals()) {
671 return -TARGET_ERESTART
;
674 k
= &sigact_table
[sig
- 1];
676 oact
->_sa_handler
= tswapal(k
->_sa_handler
);
677 oact
->sa_flags
= tswap32(k
->sa_flags
);
678 oact
->sa_mask
= k
->sa_mask
;
681 k
->_sa_handler
= tswapal(act
->_sa_handler
);
682 k
->sa_flags
= tswap32(act
->sa_flags
);
683 k
->sa_mask
= act
->sa_mask
;
685 /* Update the host signal state. */
686 host_sig
= target_to_host_signal(sig
);
687 if (host_sig
!= SIGSEGV
&& host_sig
!= SIGBUS
) {
688 memset(&act1
, 0, sizeof(struct sigaction
));
689 sigfillset(&act1
.sa_mask
);
690 act1
.sa_flags
= SA_SIGINFO
;
691 if (k
->sa_flags
& TARGET_SA_RESTART
) {
692 act1
.sa_flags
|= SA_RESTART
;
695 * Note: It is important to update the host kernel signal mask to
696 * avoid getting unexpected interrupted system calls.
698 if (k
->_sa_handler
== TARGET_SIG_IGN
) {
699 act1
.sa_sigaction
= (void *)SIG_IGN
;
700 } else if (k
->_sa_handler
== TARGET_SIG_DFL
) {
701 if (fatal_signal(sig
)) {
702 act1
.sa_sigaction
= host_signal_handler
;
704 act1
.sa_sigaction
= (void *)SIG_DFL
;
707 act1
.sa_sigaction
= host_signal_handler
;
709 ret
= sigaction(host_sig
, &act1
, NULL
);
715 static inline abi_ulong
get_sigframe(struct target_sigaction
*ka
,
716 CPUArchState
*env
, size_t frame_size
)
718 TaskState
*ts
= (TaskState
*)thread_cpu
->opaque
;
721 /* Use default user stack */
722 sp
= get_sp_from_cpustate(env
);
724 if ((ka
->sa_flags
& TARGET_SA_ONSTACK
) && sas_ss_flags(ts
, sp
) == 0) {
725 sp
= ts
->sigaltstack_used
.ss_sp
+ ts
->sigaltstack_used
.ss_size
;
728 /* TODO: make this a target_arch function / define */
729 #if defined(TARGET_ARM)
730 return (sp
- frame_size
) & ~7;
731 #elif defined(TARGET_AARCH64)
732 return (sp
- frame_size
) & ~15;
734 return sp
- frame_size
;
738 /* compare to $M/$M/exec_machdep.c sendsig and sys/kern/kern_sig.c sigexit */
740 static void setup_frame(int sig
, int code
, struct target_sigaction
*ka
,
741 target_sigset_t
*set
, target_siginfo_t
*tinfo
, CPUArchState
*env
)
743 struct target_sigframe
*frame
;
744 abi_ulong frame_addr
;
747 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
748 trace_user_setup_frame(env
, frame_addr
);
749 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0)) {
750 unlock_user_struct(frame
, frame_addr
, 1);
751 dump_core_and_abort(TARGET_SIGILL
);
755 memset(frame
, 0, sizeof(*frame
));
756 setup_sigframe_arch(env
, frame_addr
, frame
, 0);
758 for (i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
759 __put_user(set
->__bits
[i
], &frame
->sf_uc
.uc_sigmask
.__bits
[i
]);
763 frame
->sf_si
.si_signo
= tinfo
->si_signo
;
764 frame
->sf_si
.si_errno
= tinfo
->si_errno
;
765 frame
->sf_si
.si_code
= tinfo
->si_code
;
766 frame
->sf_si
.si_pid
= tinfo
->si_pid
;
767 frame
->sf_si
.si_uid
= tinfo
->si_uid
;
768 frame
->sf_si
.si_status
= tinfo
->si_status
;
769 frame
->sf_si
.si_addr
= tinfo
->si_addr
;
770 /* see host_to_target_siginfo_noswap() for more details */
771 frame
->sf_si
.si_value
.sival_ptr
= tinfo
->si_value
.sival_ptr
;
773 * At this point, whatever is in the _reason union is complete
774 * and in target order, so just copy the whole thing over, even
775 * if it's too large for this specific signal.
776 * host_to_target_siginfo_noswap() and tswap_siginfo() have ensured
779 memcpy(&frame
->sf_si
._reason
, &tinfo
->_reason
,
780 sizeof(tinfo
->_reason
));
783 set_sigtramp_args(env
, sig
, frame
, frame_addr
, ka
);
785 unlock_user_struct(frame
, frame_addr
, 1);
788 static int reset_signal_mask(target_ucontext_t
*ucontext
)
792 target_sigset_t target_set
;
793 TaskState
*ts
= (TaskState
*)thread_cpu
->opaque
;
795 for (i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
796 __get_user(target_set
.__bits
[i
], &ucontext
->uc_sigmask
.__bits
[i
]);
798 target_to_host_sigset_internal(&blocked
, &target_set
);
799 ts
->signal_mask
= blocked
;
804 /* See sys/$M/$M/exec_machdep.c sigreturn() */
805 long do_sigreturn(CPUArchState
*env
, abi_ulong addr
)
808 abi_ulong target_ucontext
;
809 target_ucontext_t
*ucontext
= NULL
;
811 /* Get the target ucontext address from the stack frame */
812 ret
= get_ucontext_sigreturn(env
, addr
, &target_ucontext
);
816 trace_user_do_sigreturn(env
, addr
);
817 if (!lock_user_struct(VERIFY_READ
, ucontext
, target_ucontext
, 0)) {
821 /* Set the register state back to before the signal. */
822 if (set_mcontext(env
, &ucontext
->uc_mcontext
, 1)) {
826 /* And reset the signal mask. */
827 if (reset_signal_mask(ucontext
)) {
831 unlock_user_struct(ucontext
, target_ucontext
, 0);
832 return -TARGET_EJUSTRETURN
;
835 if (ucontext
!= NULL
) {
836 unlock_user_struct(ucontext
, target_ucontext
, 0);
838 return -TARGET_EFAULT
;
841 void signal_init(void)
843 TaskState
*ts
= (TaskState
*)thread_cpu
->opaque
;
844 struct sigaction act
;
845 struct sigaction oact
;
849 /* Set the signal mask from the host mask. */
850 sigprocmask(0, 0, &ts
->signal_mask
);
852 sigfillset(&act
.sa_mask
);
853 act
.sa_sigaction
= host_signal_handler
;
854 act
.sa_flags
= SA_SIGINFO
;
856 for (i
= 1; i
<= TARGET_NSIG
; i
++) {
858 if (i
== TARGET_SIGPROF
) {
862 host_sig
= target_to_host_signal(i
);
863 sigaction(host_sig
, NULL
, &oact
);
864 if (oact
.sa_sigaction
== (void *)SIG_IGN
) {
865 sigact_table
[i
- 1]._sa_handler
= TARGET_SIG_IGN
;
866 } else if (oact
.sa_sigaction
== (void *)SIG_DFL
) {
867 sigact_table
[i
- 1]._sa_handler
= TARGET_SIG_DFL
;
870 * If there's already a handler installed then something has
871 * gone horribly wrong, so don't even try to handle that case.
872 * Install some handlers for our own use. We need at least
873 * SIGSEGV and SIGBUS, to detect exceptions. We can not just
874 * trap all signals because it affects syscall interrupt
875 * behavior. But do trap all default-fatal signals.
877 if (fatal_signal(i
)) {
878 sigaction(host_sig
, &act
, NULL
);
883 static void handle_pending_signal(CPUArchState
*env
, int sig
,
884 struct emulated_sigtable
*k
)
886 CPUState
*cpu
= env_cpu(env
);
887 TaskState
*ts
= cpu
->opaque
;
888 struct target_sigaction
*sa
;
892 target_siginfo_t tinfo
;
893 target_sigset_t target_old_set
;
895 trace_user_handle_signal(env
, sig
);
899 sig
= gdb_handlesig(cpu
, sig
);
902 handler
= TARGET_SIG_IGN
;
904 sa
= &sigact_table
[sig
- 1];
905 handler
= sa
->_sa_handler
;
909 print_taken_signal(sig
, &k
->info
);
912 if (handler
== TARGET_SIG_DFL
) {
914 * default handler : ignore some signal. The other are job
917 if (sig
== TARGET_SIGTSTP
|| sig
== TARGET_SIGTTIN
||
918 sig
== TARGET_SIGTTOU
) {
919 kill(getpid(), SIGSTOP
);
920 } else if (sig
!= TARGET_SIGCHLD
&& sig
!= TARGET_SIGURG
&&
921 sig
!= TARGET_SIGINFO
&& sig
!= TARGET_SIGWINCH
&&
922 sig
!= TARGET_SIGCONT
) {
923 dump_core_and_abort(sig
);
925 } else if (handler
== TARGET_SIG_IGN
) {
927 } else if (handler
== TARGET_SIG_ERR
) {
928 dump_core_and_abort(sig
);
930 /* compute the blocked signals during the handler execution */
931 sigset_t
*blocked_set
;
933 target_to_host_sigset(&set
, &sa
->sa_mask
);
935 * SA_NODEFER indicates that the current signal should not be
936 * blocked during the handler.
938 if (!(sa
->sa_flags
& TARGET_SA_NODEFER
)) {
939 sigaddset(&set
, target_to_host_signal(sig
));
943 * Save the previous blocked signal state to restore it at the
944 * end of the signal execution (see do_sigreturn).
946 host_to_target_sigset_internal(&target_old_set
, &ts
->signal_mask
);
948 blocked_set
= ts
->in_sigsuspend
?
949 &ts
->sigsuspend_mask
: &ts
->signal_mask
;
950 sigorset(&ts
->signal_mask
, blocked_set
, &set
);
951 ts
->in_sigsuspend
= false;
952 sigprocmask(SIG_SETMASK
, &ts
->signal_mask
, NULL
);
954 /* XXX VM86 on x86 ??? */
956 code
= k
->info
.si_code
; /* From host, so no si_type */
957 /* prepare the stack frame of the virtual CPU */
958 if (sa
->sa_flags
& TARGET_SA_SIGINFO
) {
959 tswap_siginfo(&tinfo
, &k
->info
);
960 setup_frame(sig
, code
, sa
, &target_old_set
, &tinfo
, env
);
962 setup_frame(sig
, code
, sa
, &target_old_set
, NULL
, env
);
964 if (sa
->sa_flags
& TARGET_SA_RESETHAND
) {
965 sa
->_sa_handler
= TARGET_SIG_DFL
;
970 void process_pending_signals(CPUArchState
*env
)
972 CPUState
*cpu
= env_cpu(env
);
974 sigset_t
*blocked_set
, set
;
975 struct emulated_sigtable
*k
;
976 TaskState
*ts
= cpu
->opaque
;
978 while (qatomic_read(&ts
->signal_pending
)) {
980 sigprocmask(SIG_SETMASK
, &set
, 0);
983 sig
= ts
->sync_signal
.pending
;
986 * Synchronous signals are forced by the emulated CPU in some way.
987 * If they are set to ignore, restore the default handler (see
988 * sys/kern_sig.c trapsignal() and execsigs() for this behavior)
989 * though maybe this is done only when forcing exit for non SIGCHLD.
991 if (sigismember(&ts
->signal_mask
, target_to_host_signal(sig
)) ||
992 sigact_table
[sig
- 1]._sa_handler
== TARGET_SIG_IGN
) {
993 sigdelset(&ts
->signal_mask
, target_to_host_signal(sig
));
994 sigact_table
[sig
- 1]._sa_handler
= TARGET_SIG_DFL
;
996 handle_pending_signal(env
, sig
, &ts
->sync_signal
);
1000 for (sig
= 1; sig
<= TARGET_NSIG
; sig
++, k
++) {
1001 blocked_set
= ts
->in_sigsuspend
?
1002 &ts
->sigsuspend_mask
: &ts
->signal_mask
;
1004 !sigismember(blocked_set
, target_to_host_signal(sig
))) {
1005 handle_pending_signal(env
, sig
, k
);
1007 * Restart scan from the beginning, as handle_pending_signal
1008 * might have resulted in a new synchronous signal (eg SIGSEGV).
1015 * Unblock signals and check one more time. Unblocking signals may cause
1016 * us to take another host signal, which will set signal_pending again.
1018 qatomic_set(&ts
->signal_pending
, 0);
1019 ts
->in_sigsuspend
= false;
1020 set
= ts
->signal_mask
;
1021 sigdelset(&set
, SIGSEGV
);
1022 sigdelset(&set
, SIGBUS
);
1023 sigprocmask(SIG_SETMASK
, &set
, 0);
1025 ts
->in_sigsuspend
= false;
1028 void cpu_loop_exit_sigsegv(CPUState
*cpu
, target_ulong addr
,
1029 MMUAccessType access_type
, bool maperr
, uintptr_t ra
)
1031 const struct TCGCPUOps
*tcg_ops
= CPU_GET_CLASS(cpu
)->tcg_ops
;
1033 if (tcg_ops
->record_sigsegv
) {
1034 tcg_ops
->record_sigsegv(cpu
, addr
, access_type
, maperr
, ra
);
1037 force_sig_fault(TARGET_SIGSEGV
,
1038 maperr
? TARGET_SEGV_MAPERR
: TARGET_SEGV_ACCERR
,
1040 cpu
->exception_index
= EXCP_INTERRUPT
;
1041 cpu_loop_exit_restore(cpu
, ra
);
1044 void cpu_loop_exit_sigbus(CPUState
*cpu
, target_ulong addr
,
1045 MMUAccessType access_type
, uintptr_t ra
)
1047 const struct TCGCPUOps
*tcg_ops
= CPU_GET_CLASS(cpu
)->tcg_ops
;
1049 if (tcg_ops
->record_sigbus
) {
1050 tcg_ops
->record_sigbus(cpu
, addr
, access_type
, ra
);
1053 force_sig_fault(TARGET_SIGBUS
, TARGET_BUS_ADRALN
, addr
);
1054 cpu
->exception_index
= EXCP_INTERRUPT
;
1055 cpu_loop_exit_restore(cpu
, ra
);