Revision 55f8d6ac
| b/cpus.c | ||
|---|---|---|
| 222 | 222 |
close(fds[1]); |
| 223 | 223 |
return err; |
| 224 | 224 |
} |
| 225 |
#else |
|
| 225 |
|
|
| 226 |
#ifdef CONFIG_IOTHREAD |
|
| 227 |
static void dummy_signal(int sig) |
|
| 228 |
{
|
|
| 229 |
} |
|
| 230 |
#endif |
|
| 231 |
|
|
| 232 |
#else /* _WIN32 */ |
|
| 233 |
|
|
| 226 | 234 |
HANDLE qemu_event_handle; |
| 227 | 235 |
|
| 228 | 236 |
static void dummy_event_handler(void *opaque) |
| ... | ... | |
| 248 | 256 |
exit (1); |
| 249 | 257 |
} |
| 250 | 258 |
} |
| 251 |
#endif |
|
| 259 |
#endif /* _WIN32 */
|
|
| 252 | 260 |
|
| 253 | 261 |
#ifndef CONFIG_IOTHREAD |
| 254 | 262 |
int qemu_init_main_loop(void) |
| ... | ... | |
| 348 | 356 |
static QemuCond qemu_pause_cond; |
| 349 | 357 |
static QemuCond qemu_work_cond; |
| 350 | 358 |
|
| 351 |
static void tcg_init_ipi(void); |
|
| 352 |
static void kvm_init_ipi(CPUState *env); |
|
| 353 |
static sigset_t block_io_signals(void); |
|
| 354 |
|
|
| 355 | 359 |
/* If we have signalfd, we mask out the signals we want to handle and then |
| 356 | 360 |
* use signalfd to listen for them. We rely on whatever the current signal |
| 357 | 361 |
* handler is to dispatch the signals when we receive them. |
| ... | ... | |
| 387 | 391 |
} |
| 388 | 392 |
} |
| 389 | 393 |
|
| 394 |
static void cpu_signal(int sig) |
|
| 395 |
{
|
|
| 396 |
if (cpu_single_env) {
|
|
| 397 |
cpu_exit(cpu_single_env); |
|
| 398 |
} |
|
| 399 |
exit_request = 1; |
|
| 400 |
} |
|
| 401 |
|
|
| 402 |
static void qemu_kvm_init_cpu_signals(CPUState *env) |
|
| 403 |
{
|
|
| 404 |
int r; |
|
| 405 |
sigset_t set; |
|
| 406 |
struct sigaction sigact; |
|
| 407 |
|
|
| 408 |
memset(&sigact, 0, sizeof(sigact)); |
|
| 409 |
sigact.sa_handler = dummy_signal; |
|
| 410 |
sigaction(SIG_IPI, &sigact, NULL); |
|
| 411 |
|
|
| 412 |
pthread_sigmask(SIG_BLOCK, NULL, &set); |
|
| 413 |
sigdelset(&set, SIG_IPI); |
|
| 414 |
sigdelset(&set, SIGBUS); |
|
| 415 |
r = kvm_set_signal_mask(env, &set); |
|
| 416 |
if (r) {
|
|
| 417 |
fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r)); |
|
| 418 |
exit(1); |
|
| 419 |
} |
|
| 420 |
} |
|
| 421 |
|
|
| 422 |
static void qemu_tcg_init_cpu_signals(void) |
|
| 423 |
{
|
|
| 424 |
sigset_t set; |
|
| 425 |
struct sigaction sigact; |
|
| 426 |
|
|
| 427 |
memset(&sigact, 0, sizeof(sigact)); |
|
| 428 |
sigact.sa_handler = cpu_signal; |
|
| 429 |
sigaction(SIG_IPI, &sigact, NULL); |
|
| 430 |
|
|
| 431 |
sigemptyset(&set); |
|
| 432 |
sigaddset(&set, SIG_IPI); |
|
| 433 |
pthread_sigmask(SIG_UNBLOCK, &set, NULL); |
|
| 434 |
} |
|
| 435 |
|
|
| 436 |
static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo, |
|
| 437 |
void *ctx); |
|
| 438 |
|
|
| 439 |
static sigset_t block_io_signals(void) |
|
| 440 |
{
|
|
| 441 |
sigset_t set; |
|
| 442 |
struct sigaction action; |
|
| 443 |
|
|
| 444 |
/* SIGUSR2 used by posix-aio-compat.c */ |
|
| 445 |
sigemptyset(&set); |
|
| 446 |
sigaddset(&set, SIGUSR2); |
|
| 447 |
pthread_sigmask(SIG_UNBLOCK, &set, NULL); |
|
| 448 |
|
|
| 449 |
sigemptyset(&set); |
|
| 450 |
sigaddset(&set, SIGIO); |
|
| 451 |
sigaddset(&set, SIGALRM); |
|
| 452 |
sigaddset(&set, SIG_IPI); |
|
| 453 |
sigaddset(&set, SIGBUS); |
|
| 454 |
pthread_sigmask(SIG_BLOCK, &set, NULL); |
|
| 455 |
|
|
| 456 |
memset(&action, 0, sizeof(action)); |
|
| 457 |
action.sa_flags = SA_SIGINFO; |
|
| 458 |
action.sa_sigaction = (void (*)(int, siginfo_t*, void*))sigbus_handler; |
|
| 459 |
sigaction(SIGBUS, &action, NULL); |
|
| 460 |
prctl(PR_MCE_KILL, 1, 1, 0, 0); |
|
| 461 |
|
|
| 462 |
return set; |
|
| 463 |
} |
|
| 464 |
|
|
| 390 | 465 |
static int qemu_signalfd_init(sigset_t mask) |
| 391 | 466 |
{
|
| 392 | 467 |
int sigfd; |
| ... | ... | |
| 615 | 690 |
exit(1); |
| 616 | 691 |
} |
| 617 | 692 |
|
| 618 |
kvm_init_ipi(env);
|
|
| 693 |
qemu_kvm_init_cpu_signals(env);
|
|
| 619 | 694 |
|
| 620 | 695 |
/* signal CPU creation */ |
| 621 | 696 |
env->created = 1; |
| ... | ... | |
| 638 | 713 |
{
|
| 639 | 714 |
CPUState *env = arg; |
| 640 | 715 |
|
| 641 |
tcg_init_ipi();
|
|
| 716 |
qemu_tcg_init_cpu_signals();
|
|
| 642 | 717 |
qemu_thread_self(env->thread); |
| 643 | 718 |
|
| 644 | 719 |
/* signal CPU creation */ |
| ... | ... | |
| 679 | 754 |
return qemu_thread_equal(&this, env->thread); |
| 680 | 755 |
} |
| 681 | 756 |
|
| 682 |
static void cpu_signal(int sig) |
|
| 683 |
{
|
|
| 684 |
if (cpu_single_env) |
|
| 685 |
cpu_exit(cpu_single_env); |
|
| 686 |
exit_request = 1; |
|
| 687 |
} |
|
| 688 |
|
|
| 689 |
static void tcg_init_ipi(void) |
|
| 690 |
{
|
|
| 691 |
sigset_t set; |
|
| 692 |
struct sigaction sigact; |
|
| 693 |
|
|
| 694 |
memset(&sigact, 0, sizeof(sigact)); |
|
| 695 |
sigact.sa_handler = cpu_signal; |
|
| 696 |
sigaction(SIG_IPI, &sigact, NULL); |
|
| 697 |
|
|
| 698 |
sigemptyset(&set); |
|
| 699 |
sigaddset(&set, SIG_IPI); |
|
| 700 |
pthread_sigmask(SIG_UNBLOCK, &set, NULL); |
|
| 701 |
} |
|
| 702 |
|
|
| 703 |
static void dummy_signal(int sig) |
|
| 704 |
{
|
|
| 705 |
} |
|
| 706 |
|
|
| 707 |
static void kvm_init_ipi(CPUState *env) |
|
| 708 |
{
|
|
| 709 |
int r; |
|
| 710 |
sigset_t set; |
|
| 711 |
struct sigaction sigact; |
|
| 712 |
|
|
| 713 |
memset(&sigact, 0, sizeof(sigact)); |
|
| 714 |
sigact.sa_handler = dummy_signal; |
|
| 715 |
sigaction(SIG_IPI, &sigact, NULL); |
|
| 716 |
|
|
| 717 |
pthread_sigmask(SIG_BLOCK, NULL, &set); |
|
| 718 |
sigdelset(&set, SIG_IPI); |
|
| 719 |
sigdelset(&set, SIGBUS); |
|
| 720 |
r = kvm_set_signal_mask(env, &set); |
|
| 721 |
if (r) {
|
|
| 722 |
fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(r)); |
|
| 723 |
exit(1); |
|
| 724 |
} |
|
| 725 |
} |
|
| 726 |
|
|
| 727 |
static sigset_t block_io_signals(void) |
|
| 728 |
{
|
|
| 729 |
sigset_t set; |
|
| 730 |
struct sigaction action; |
|
| 731 |
|
|
| 732 |
/* SIGUSR2 used by posix-aio-compat.c */ |
|
| 733 |
sigemptyset(&set); |
|
| 734 |
sigaddset(&set, SIGUSR2); |
|
| 735 |
pthread_sigmask(SIG_UNBLOCK, &set, NULL); |
|
| 736 |
|
|
| 737 |
sigemptyset(&set); |
|
| 738 |
sigaddset(&set, SIGIO); |
|
| 739 |
sigaddset(&set, SIGALRM); |
|
| 740 |
sigaddset(&set, SIG_IPI); |
|
| 741 |
sigaddset(&set, SIGBUS); |
|
| 742 |
pthread_sigmask(SIG_BLOCK, &set, NULL); |
|
| 743 |
|
|
| 744 |
memset(&action, 0, sizeof(action)); |
|
| 745 |
action.sa_flags = SA_SIGINFO; |
|
| 746 |
action.sa_sigaction = (void (*)(int, siginfo_t*, void*))sigbus_handler; |
|
| 747 |
sigaction(SIGBUS, &action, NULL); |
|
| 748 |
prctl(PR_MCE_KILL, 1, 1, 0, 0); |
|
| 749 |
|
|
| 750 |
return set; |
|
| 751 |
} |
|
| 752 |
|
|
| 753 | 757 |
void qemu_mutex_lock_iothread(void) |
| 754 | 758 |
{
|
| 755 | 759 |
if (kvm_enabled()) {
|
Also available in: Unified diff