Revision 55f8d6ac cpus.c

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