cpus.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 /* Needed early for CONFIG_BSD etc. */
  26 #include "config-host.h"
  27
  28 #include "monitor.h"
  29 #include "sysemu.h"
  30 #include "gdbstub.h"
  31 #include "dma.h"
  32 #include "kvm.h"
  33
  34 #include "qemu-thread.h"
  35 #include "cpus.h"
  36
  37 #ifndef _WIN32
  38 #include "compatfd.h"
  39 #endif
  40
  41 #ifdef SIGRTMIN
  42 #define SIG_IPI (SIGRTMIN+4)
  43 #else
  44 #define SIG_IPI SIGUSR1
  45 #endif
  46
  47 #ifdef CONFIG_LINUX
  48
  49 #include <sys/prctl.h>
  50
  51 #ifndef PR_MCE_KILL
  52 #define PR_MCE_KILL 33
  53 #endif
  54
  55 #ifndef PR_MCE_KILL_SET
  56 #define PR_MCE_KILL_SET 1
  57 #endif
  58
  59 #ifndef PR_MCE_KILL_EARLY
  60 #define PR_MCE_KILL_EARLY 1
  61 #endif
  62
  63 #endif /* CONFIG_LINUX */
  64
  65 static CPUState *next_cpu;
  66
  67 /***********************************************************/
  68 void hw_error(const char *fmt, ...)
  69 {
  70     va_list ap;
  71     CPUState *env;
  72
  73     va_start(ap, fmt);
  74     fprintf(stderr, "qemu: hardware error: ");
  75     vfprintf(stderr, fmt, ap);
  76     fprintf(stderr, "\n");
  77     for(env = first_cpu; env != NULL; env = env->next_cpu) {
  78         fprintf(stderr, "CPU #%d:\n", env->cpu_index);
  79 #ifdef TARGET_I386
  80         cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
  81 #else
  82         cpu_dump_state(env, stderr, fprintf, 0);
  83 #endif
  84     }
  85     va_end(ap);
  86     abort();
  87 }
  88
  89 void cpu_synchronize_all_states(void)
  90 {
  91     CPUState *cpu;
  92
  93     for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
  94         cpu_synchronize_state(cpu);
  95     }
  96 }
  97
  98 void cpu_synchronize_all_post_reset(void)
  99 {
 100     CPUState *cpu;
 101
 102     for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
 103         cpu_synchronize_post_reset(cpu);
 104     }
 105 }
 106
 107 void cpu_synchronize_all_post_init(void)
 108 {
 109     CPUState *cpu;
 110
 111     for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
 112         cpu_synchronize_post_init(cpu);
 113     }
 114 }
 115
 116 int cpu_is_stopped(CPUState *env)
 117 {
 118     return !vm_running || env->stopped;
 119 }
 120
 121 static void do_vm_stop(int reason)
 122 {
 123     if (vm_running) {
 124         cpu_disable_ticks();
 125         vm_running = 0;
 126         pause_all_vcpus();
 127         vm_state_notify(0, reason);
 128         qemu_aio_flush();
 129         bdrv_flush_all();
 130         monitor_protocol_event(QEVENT_STOP, NULL);
 131     }
 132 }
 133
 134 static int cpu_can_run(CPUState *env)
 135 {
 136     if (env->stop) {
 137         return 0;
 138     }
 139     if (env->stopped || !vm_running) {
 140         return 0;
 141     }
 142     return 1;
 143 }
 144
 145 static bool cpu_thread_is_idle(CPUState *env)
 146 {
 147     if (env->stop || env->queued_work_first) {
 148         return false;
 149     }
 150     if (env->stopped || !vm_running) {
 151         return true;
 152     }
 153     if (!env->halted || qemu_cpu_has_work(env) ||
 154         (kvm_enabled() && kvm_irqchip_in_kernel())) {
 155         return false;
 156     }
 157     return true;
 158 }
 159
 160 bool all_cpu_threads_idle(void)
 161 {
 162     CPUState *env;
 163
 164     for (env = first_cpu; env != NULL; env = env->next_cpu) {
 165         if (!cpu_thread_is_idle(env)) {
 166             return false;
 167         }
 168     }
 169     return true;
 170 }
 171
 172 static void cpu_handle_guest_debug(CPUState *env)
 173 {
 174     gdb_set_stop_cpu(env);
 175     qemu_system_debug_request();
 176 #ifdef CONFIG_IOTHREAD
 177     env->stopped = 1;
 178 #endif
 179 }
 180
 181 #ifdef CONFIG_IOTHREAD
 182 static void cpu_signal(int sig)
 183 {
 184     if (cpu_single_env) {
 185         cpu_exit(cpu_single_env);
 186     }
 187     exit_request = 1;
 188 }
 189 #endif
 190
 191 #ifdef CONFIG_LINUX
 192 static void sigbus_reraise(void)
 193 {
 194     sigset_t set;
 195     struct sigaction action;
 196
 197     memset(&action, 0, sizeof(action));
 198     action.sa_handler = SIG_DFL;
 199     if (!sigaction(SIGBUS, &action, NULL)) {
 200         raise(SIGBUS);
 201         sigemptyset(&set);
 202         sigaddset(&set, SIGBUS);
 203         sigprocmask(SIG_UNBLOCK, &set, NULL);
 204     }
 205     perror("Failed to re-raise SIGBUS!\n");
 206     abort();
 207 }
 208
 209 static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo,
 210                            void *ctx)
 211 {
 212     if (kvm_on_sigbus(siginfo->ssi_code,
 213                       (void *)(intptr_t)siginfo->ssi_addr)) {
 214         sigbus_reraise();
 215     }
 216 }
 217
 218 static void qemu_init_sigbus(void)
 219 {
 220     struct sigaction action;
 221
 222     memset(&action, 0, sizeof(action));
 223     action.sa_flags = SA_SIGINFO;
 224     action.sa_sigaction = (void (*)(int, siginfo_t*, void*))sigbus_handler;
 225     sigaction(SIGBUS, &action, NULL);
 226
 227     prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, 0, 0);
 228 }
 229
 230 static void qemu_kvm_eat_signals(CPUState *env)
 231 {
 232     struct timespec ts = { 0, 0 };
 233     siginfo_t siginfo;
 234     sigset_t waitset;
 235     sigset_t chkset;
 236     int r;
 237
 238     sigemptyset(&waitset);
 239     sigaddset(&waitset, SIG_IPI);
 240     sigaddset(&waitset, SIGBUS);
 241
 242     do {
 243         r = sigtimedwait(&waitset, &siginfo, &ts);
 244         if (r == -1 && !(errno == EAGAIN || errno == EINTR)) {
 245             perror("sigtimedwait");
 246             exit(1);
 247         }
 248
 249         switch (r) {
 250         case SIGBUS:
 251             if (kvm_on_sigbus_vcpu(env, siginfo.si_code, siginfo.si_addr)) {
 252                 sigbus_reraise();
 253             }
 254             break;
 255         default:
 256             break;
 257         }
 258
 259         r = sigpending(&chkset);
 260         if (r == -1) {
 261             perror("sigpending");
 262             exit(1);
 263         }
 264     } while (sigismember(&chkset, SIG_IPI) || sigismember(&chkset, SIGBUS));
 265
 266 #ifndef CONFIG_IOTHREAD
 267     if (sigismember(&chkset, SIGIO) || sigismember(&chkset, SIGALRM)) {
 268         qemu_notify_event();
 269     }
 270 #endif
 271 }
 272
 273 #else /* !CONFIG_LINUX */
 274
 275 static void qemu_init_sigbus(void)
 276 {
 277 }
 278
 279 static void qemu_kvm_eat_signals(CPUState *env)
 280 {
 281 }
 282 #endif /* !CONFIG_LINUX */
 283
 284 #ifndef _WIN32
 285 static int io_thread_fd = -1;
 286
 287 static void qemu_event_increment(void)
 288 {
 289     /* Write 8 bytes to be compatible with eventfd.  */
 290     static const uint64_t val = 1;
 291     ssize_t ret;
 292
 293     if (io_thread_fd == -1) {
 294         return;
 295     }
 296     do {
 297         ret = write(io_thread_fd, &val, sizeof(val));
 298     } while (ret < 0 && errno == EINTR);
 299
 300     /* EAGAIN is fine, a read must be pending.  */
 301     if (ret < 0 && errno != EAGAIN) {
 302         fprintf(stderr, "qemu_event_increment: write() failed: %s\n",
 303                 strerror(errno));
 304         exit (1);
 305     }
 306 }
 307
 308 static void qemu_event_read(void *opaque)
 309 {
 310     int fd = (intptr_t)opaque;
 311     ssize_t len;
 312     char buffer[512];
 313
 314     /* Drain the notify pipe.  For eventfd, only 8 bytes will be read.  */
 315     do {
 316         len = read(fd, buffer, sizeof(buffer));
 317     } while ((len == -1 && errno == EINTR) || len == sizeof(buffer));
 318 }
 319
 320 static int qemu_event_init(void)
 321 {
 322     int err;
 323     int fds[2];
 324
 325     err = qemu_eventfd(fds);
 326     if (err == -1) {
 327         return -errno;
 328     }
 329     err = fcntl_setfl(fds[0], O_NONBLOCK);
 330     if (err < 0) {
 331         goto fail;
 332     }
 333     err = fcntl_setfl(fds[1], O_NONBLOCK);
 334     if (err < 0) {
 335         goto fail;
 336     }
 337     qemu_set_fd_handler2(fds[0], NULL, qemu_event_read, NULL,
 338                          (void *)(intptr_t)fds[0]);
 339
 340     io_thread_fd = fds[1];
 341     return 0;
 342
 343 fail:
 344     close(fds[0]);
 345     close(fds[1]);
 346     return err;
 347 }
 348
 349 static void dummy_signal(int sig)
 350 {
 351 }
 352
 353 /* If we have signalfd, we mask out the signals we want to handle and then
 354  * use signalfd to listen for them.  We rely on whatever the current signal
 355  * handler is to dispatch the signals when we receive them.
 356  */
 357 static void sigfd_handler(void *opaque)
 358 {
 359     int fd = (intptr_t)opaque;
 360     struct qemu_signalfd_siginfo info;
 361     struct sigaction action;
 362     ssize_t len;
 363
 364     while (1) {
 365         do {
 366             len = read(fd, &info, sizeof(info));
 367         } while (len == -1 && errno == EINTR);
 368
 369         if (len == -1 && errno == EAGAIN) {
 370             break;
 371         }
 372
 373         if (len != sizeof(info)) {
 374             printf("read from sigfd returned %zd: %m\n", len);
 375             return;
 376         }
 377
 378         sigaction(info.ssi_signo, NULL, &action);
 379         if ((action.sa_flags & SA_SIGINFO) && action.sa_sigaction) {
 380             action.sa_sigaction(info.ssi_signo,
 381                                 (siginfo_t *)&info, NULL);
 382         } else if (action.sa_handler) {
 383             action.sa_handler(info.ssi_signo);
 384         }
 385     }
 386 }
 387
 388 static int qemu_signal_init(void)
 389 {
 390     int sigfd;
 391     sigset_t set;
 392
 393 #ifdef CONFIG_IOTHREAD
 394     /* SIGUSR2 used by posix-aio-compat.c */
 395     sigemptyset(&set);
 396     sigaddset(&set, SIGUSR2);
 397     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
 398
 399     /*
 400      * SIG_IPI must be blocked in the main thread and must not be caught
 401      * by sigwait() in the signal thread. Otherwise, the cpu thread will
 402      * not catch it reliably.
 403      */
 404     sigemptyset(&set);
 405     sigaddset(&set, SIG_IPI);
 406     pthread_sigmask(SIG_BLOCK, &set, NULL);
 407
 408     sigemptyset(&set);
 409     sigaddset(&set, SIGIO);
 410     sigaddset(&set, SIGALRM);
 411     sigaddset(&set, SIGBUS);
 412 #else
 413     sigemptyset(&set);
 414     sigaddset(&set, SIGBUS);
 415     if (kvm_enabled()) {
 416         /*
 417          * We need to process timer signals synchronously to avoid a race
 418          * between exit_request check and KVM vcpu entry.
 419          */
 420         sigaddset(&set, SIGIO);
 421         sigaddset(&set, SIGALRM);
 422     }
 423 #endif
 424     pthread_sigmask(SIG_BLOCK, &set, NULL);
 425
 426     sigfd = qemu_signalfd(&set);
 427     if (sigfd == -1) {
 428         fprintf(stderr, "failed to create signalfd\n");
 429         return -errno;
 430     }
 431
 432     fcntl_setfl(sigfd, O_NONBLOCK);
 433
 434     qemu_set_fd_handler2(sigfd, NULL, sigfd_handler, NULL,
 435                          (void *)(intptr_t)sigfd);
 436
 437     return 0;
 438 }
 439
 440 static void qemu_kvm_init_cpu_signals(CPUState *env)
 441 {
 442     int r;
 443     sigset_t set;
 444     struct sigaction sigact;
 445
 446     memset(&sigact, 0, sizeof(sigact));
 447     sigact.sa_handler = dummy_signal;
 448     sigaction(SIG_IPI, &sigact, NULL);
 449
 450 #ifdef CONFIG_IOTHREAD
 451     pthread_sigmask(SIG_BLOCK, NULL, &set);
 452     sigdelset(&set, SIG_IPI);
 453     sigdelset(&set, SIGBUS);
 454     r = kvm_set_signal_mask(env, &set);
 455     if (r) {
 456         fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));
 457         exit(1);
 458     }
 459 #else
 460     sigemptyset(&set);
 461     sigaddset(&set, SIG_IPI);
 462     sigaddset(&set, SIGIO);
 463     sigaddset(&set, SIGALRM);
 464     pthread_sigmask(SIG_BLOCK, &set, NULL);
 465
 466     pthread_sigmask(SIG_BLOCK, NULL, &set);
 467     sigdelset(&set, SIGIO);
 468     sigdelset(&set, SIGALRM);
 469 #endif
 470     sigdelset(&set, SIG_IPI);
 471     sigdelset(&set, SIGBUS);
 472     r = kvm_set_signal_mask(env, &set);
 473     if (r) {
 474         fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));
 475         exit(1);
 476     }
 477 }
 478
 479 static void qemu_tcg_init_cpu_signals(void)
 480 {
 481 #ifdef CONFIG_IOTHREAD
 482     sigset_t set;
 483     struct sigaction sigact;
 484
 485     memset(&sigact, 0, sizeof(sigact));
 486     sigact.sa_handler = cpu_signal;
 487     sigaction(SIG_IPI, &sigact, NULL);
 488
 489     sigemptyset(&set);
 490     sigaddset(&set, SIG_IPI);
 491     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
 492 #endif
 493 }
 494
 495 #else /* _WIN32 */
 496
 497 HANDLE qemu_event_handle;
 498
 499 static void dummy_event_handler(void *opaque)
 500 {
 501 }
 502
 503 static int qemu_event_init(void)
 504 {
 505     qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
 506     if (!qemu_event_handle) {
 507         fprintf(stderr, "Failed CreateEvent: %ld\n", GetLastError());
 508         return -1;
 509     }
 510     qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
 511     return 0;
 512 }
 513
 514 static void qemu_event_increment(void)
 515 {
 516     if (!SetEvent(qemu_event_handle)) {
 517         fprintf(stderr, "qemu_event_increment: SetEvent failed: %ld\n",
 518                 GetLastError());
 519         exit (1);
 520     }
 521 }
 522
 523 static int qemu_signal_init(void)
 524 {
 525     return 0;
 526 }
 527
 528 static void qemu_kvm_init_cpu_signals(CPUState *env)
 529 {
 530     abort();
 531 }
 532
 533 static void qemu_tcg_init_cpu_signals(void)
 534 {
 535 }
 536 #endif /* _WIN32 */
 537
 538 #ifndef CONFIG_IOTHREAD
 539 int qemu_init_main_loop(void)
 540 {
 541     int ret;
 542
 543     ret = qemu_signal_init();
 544     if (ret) {
 545         return ret;
 546     }
 547
 548     qemu_init_sigbus();
 549
 550     return qemu_event_init();
 551 }
 552
 553 void qemu_main_loop_start(void)
 554 {
 555 }
 556
 557 void qemu_init_vcpu(void *_env)
 558 {
 559     CPUState *env = _env;
 560     int r;
 561
 562     env->nr_cores = smp_cores;
 563     env->nr_threads = smp_threads;
 564
 565     if (kvm_enabled()) {
 566         r = kvm_init_vcpu(env);
 567         if (r < 0) {
 568             fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r));
 569             exit(1);
 570         }
 571         qemu_kvm_init_cpu_signals(env);
 572     } else {
 573         qemu_tcg_init_cpu_signals();
 574     }
 575 }
 576
 577 int qemu_cpu_is_self(void *env)
 578 {
 579     return 1;
 580 }
 581
 582 void run_on_cpu(CPUState *env, void (*func)(void *data), void *data)
 583 {
 584     func(data);
 585 }
 586
 587 void resume_all_vcpus(void)
 588 {
 589 }
 590
 591 void pause_all_vcpus(void)
 592 {
 593 }
 594
 595 void qemu_cpu_kick(void *env)
 596 {
 597 }
 598
 599 void qemu_cpu_kick_self(void)
 600 {
 601 #ifndef _WIN32
 602     assert(cpu_single_env);
 603
 604     raise(SIG_IPI);
 605 #else
 606     abort();
 607 #endif
 608 }
 609
 610 void qemu_notify_event(void)
 611 {
 612     CPUState *env = cpu_single_env;
 613
 614     qemu_event_increment ();
 615     if (env) {
 616         cpu_exit(env);
 617     }
 618     if (next_cpu && env != next_cpu) {
 619         cpu_exit(next_cpu);
 620     }
 621     exit_request = 1;
 622 }
 623
 624 void qemu_mutex_lock_iothread(void) {}
 625 void qemu_mutex_unlock_iothread(void) {}
 626
 627 void cpu_stop_current(void)
 628 {
 629 }
 630
 631 void vm_stop(int reason)
 632 {
 633     do_vm_stop(reason);
 634 }
 635
 636 #else /* CONFIG_IOTHREAD */
 637
 638 QemuMutex qemu_global_mutex;
 639 static QemuCond qemu_io_proceeded_cond;
 640 static bool iothread_requesting_mutex;
 641
 642 static QemuThread io_thread;
 643
 644 static QemuThread *tcg_cpu_thread;
 645 static QemuCond *tcg_halt_cond;
 646
 647 static int qemu_system_ready;
 648 /* cpu creation */
 649 static QemuCond qemu_cpu_cond;
 650 /* system init */
 651 static QemuCond qemu_system_cond;
 652 static QemuCond qemu_pause_cond;
 653 static QemuCond qemu_work_cond;
 654
 655 int qemu_init_main_loop(void)
 656 {
 657     int ret;
 658
 659     qemu_init_sigbus();
 660
 661     ret = qemu_signal_init();
 662     if (ret) {
 663         return ret;
 664     }
 665
 666     /* Note eventfd must be drained before signalfd handlers run */
 667     ret = qemu_event_init();
 668     if (ret) {
 669         return ret;
 670     }
 671
 672     qemu_cond_init(&qemu_cpu_cond);
 673     qemu_cond_init(&qemu_system_cond);
 674     qemu_cond_init(&qemu_pause_cond);
 675     qemu_cond_init(&qemu_work_cond);
 676     qemu_cond_init(&qemu_io_proceeded_cond);
 677     qemu_mutex_init(&qemu_global_mutex);
 678     qemu_mutex_lock(&qemu_global_mutex);
 679
 680     qemu_thread_get_self(&io_thread);
 681
 682     return 0;
 683 }
 684
 685 void qemu_main_loop_start(void)
 686 {
 687     qemu_system_ready = 1;
 688     qemu_cond_broadcast(&qemu_system_cond);
 689 }
 690
 691 void run_on_cpu(CPUState *env, void (*func)(void *data), void *data)
 692 {
 693     struct qemu_work_item wi;
 694
 695     if (qemu_cpu_is_self(env)) {
 696         func(data);
 697         return;
 698     }
 699
 700     wi.func = func;
 701     wi.data = data;
 702     if (!env->queued_work_first) {
 703         env->queued_work_first = &wi;
 704     } else {
 705         env->queued_work_last->next = &wi;
 706     }
 707     env->queued_work_last = &wi;
 708     wi.next = NULL;
 709     wi.done = false;
 710
 711     qemu_cpu_kick(env);
 712     while (!wi.done) {
 713         CPUState *self_env = cpu_single_env;
 714
 715         qemu_cond_wait(&qemu_work_cond, &qemu_global_mutex);
 716         cpu_single_env = self_env;
 717     }
 718 }
 719
 720 static void flush_queued_work(CPUState *env)
 721 {
 722     struct qemu_work_item *wi;
 723
 724     if (!env->queued_work_first) {
 725         return;
 726     }
 727
 728     while ((wi = env->queued_work_first)) {
 729         env->queued_work_first = wi->next;
 730         wi->func(wi->data);
 731         wi->done = true;
 732     }
 733     env->queued_work_last = NULL;
 734     qemu_cond_broadcast(&qemu_work_cond);
 735 }
 736
 737 static void qemu_wait_io_event_common(CPUState *env)
 738 {
 739     if (env->stop) {
 740         env->stop = 0;
 741         env->stopped = 1;
 742         qemu_cond_signal(&qemu_pause_cond);
 743     }
 744     flush_queued_work(env);
 745     env->thread_kicked = false;
 746 }
 747
 748 static void qemu_tcg_wait_io_event(void)
 749 {
 750     CPUState *env;
 751
 752     while (all_cpu_threads_idle()) {
 753        /* Start accounting real time to the virtual clock if the CPUs
 754           are idle.  */
 755         qemu_clock_warp(vm_clock);
 756         qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
 757     }
 758
 759     while (iothread_requesting_mutex) {
 760         qemu_cond_wait(&qemu_io_proceeded_cond, &qemu_global_mutex);
 761     }
 762
 763     for (env = first_cpu; env != NULL; env = env->next_cpu) {
 764         qemu_wait_io_event_common(env);
 765     }
 766 }
 767
 768 static void qemu_kvm_wait_io_event(CPUState *env)
 769 {
 770     while (cpu_thread_is_idle(env)) {
 771         qemu_cond_wait(env->halt_cond, &qemu_global_mutex);
 772     }
 773
 774     qemu_kvm_eat_signals(env);
 775     qemu_wait_io_event_common(env);
 776 }
 777
 778 static void *qemu_kvm_cpu_thread_fn(void *arg)
 779 {
 780     CPUState *env = arg;
 781     int r;
 782
 783     qemu_mutex_lock(&qemu_global_mutex);
 784     qemu_thread_get_self(env->thread);
 785     env->thread_id = qemu_get_thread_id();
 786
 787     r = kvm_init_vcpu(env);
 788     if (r < 0) {
 789         fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r));
 790         exit(1);
 791     }
 792
 793     qemu_kvm_init_cpu_signals(env);
 794
 795     /* signal CPU creation */
 796     env->created = 1;
 797     qemu_cond_signal(&qemu_cpu_cond);
 798
 799     /* and wait for machine initialization */
 800     while (!qemu_system_ready) {
 801         qemu_cond_wait(&qemu_system_cond, &qemu_global_mutex);
 802     }
 803
 804     while (1) {
 805         if (cpu_can_run(env)) {
 806             r = kvm_cpu_exec(env);
 807             if (r == EXCP_DEBUG) {
 808                 cpu_handle_guest_debug(env);
 809             }
 810         }
 811         qemu_kvm_wait_io_event(env);
 812     }
 813
 814     return NULL;
 815 }
 816
 817 static void *qemu_tcg_cpu_thread_fn(void *arg)
 818 {
 819     CPUState *env = arg;
 820
 821     qemu_tcg_init_cpu_signals();
 822     qemu_thread_get_self(env->thread);
 823
 824     /* signal CPU creation */
 825     qemu_mutex_lock(&qemu_global_mutex);
 826     for (env = first_cpu; env != NULL; env = env->next_cpu) {
 827         env->thread_id = qemu_get_thread_id();
 828         env->created = 1;
 829     }
 830     qemu_cond_signal(&qemu_cpu_cond);
 831
 832     /* and wait for machine initialization */
 833     while (!qemu_system_ready) {
 834         qemu_cond_wait(&qemu_system_cond, &qemu_global_mutex);
 835     }
 836
 837     while (1) {
 838         cpu_exec_all();
 839         if (use_icount && qemu_next_icount_deadline() <= 0) {
 840             qemu_notify_event();
 841         }
 842         qemu_tcg_wait_io_event();
 843     }
 844
 845     return NULL;
 846 }
 847
 848 static void qemu_cpu_kick_thread(CPUState *env)
 849 {
 850 #ifndef _WIN32
 851     int err;
 852
 853     err = pthread_kill(env->thread->thread, SIG_IPI);
 854     if (err) {
 855         fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
 856         exit(1);
 857     }
 858 #else /* _WIN32 */
 859     if (!qemu_cpu_is_self(env)) {
 860         SuspendThread(env->thread->thread);
 861         cpu_signal(0);
 862         ResumeThread(env->thread->thread);
 863     }
 864 #endif
 865 }
 866
 867 void qemu_cpu_kick(void *_env)
 868 {
 869     CPUState *env = _env;
 870
 871     qemu_cond_broadcast(env->halt_cond);
 872     if (!env->thread_kicked) {
 873         qemu_cpu_kick_thread(env);
 874         env->thread_kicked = true;
 875     }
 876 }
 877
 878 void qemu_cpu_kick_self(void)
 879 {
 880 #ifndef _WIN32
 881     assert(cpu_single_env);
 882
 883     if (!cpu_single_env->thread_kicked) {
 884         qemu_cpu_kick_thread(cpu_single_env);
 885         cpu_single_env->thread_kicked = true;
 886     }
 887 #else
 888     abort();
 889 #endif
 890 }
 891
 892 int qemu_cpu_is_self(void *_env)
 893 {
 894     CPUState *env = _env;
 895
 896     return qemu_thread_is_self(env->thread);
 897 }
 898
 899 void qemu_mutex_lock_iothread(void)
 900 {
 901     if (kvm_enabled()) {
 902         qemu_mutex_lock(&qemu_global_mutex);
 903     } else {
 904         iothread_requesting_mutex = true;
 905         if (qemu_mutex_trylock(&qemu_global_mutex)) {
 906             qemu_cpu_kick_thread(first_cpu);
 907             qemu_mutex_lock(&qemu_global_mutex);
 908         }
 909         iothread_requesting_mutex = false;
 910         qemu_cond_broadcast(&qemu_io_proceeded_cond);
 911     }
 912 }
 913
 914 void qemu_mutex_unlock_iothread(void)
 915 {
 916     qemu_mutex_unlock(&qemu_global_mutex);
 917 }
 918
 919 static int all_vcpus_paused(void)
 920 {
 921     CPUState *penv = first_cpu;
 922
 923     while (penv) {
 924         if (!penv->stopped) {
 925             return 0;
 926         }
 927         penv = (CPUState *)penv->next_cpu;
 928     }
 929
 930     return 1;
 931 }
 932
 933 void pause_all_vcpus(void)
 934 {
 935     CPUState *penv = first_cpu;
 936
 937     while (penv) {
 938         penv->stop = 1;
 939         qemu_cpu_kick(penv);
 940         penv = (CPUState *)penv->next_cpu;
 941     }
 942
 943     while (!all_vcpus_paused()) {
 944         qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
 945         penv = first_cpu;
 946         while (penv) {
 947             qemu_cpu_kick(penv);
 948             penv = (CPUState *)penv->next_cpu;
 949         }
 950     }
 951 }
 952
 953 void resume_all_vcpus(void)
 954 {
 955     CPUState *penv = first_cpu;
 956
 957     while (penv) {
 958         penv->stop = 0;
 959         penv->stopped = 0;
 960         qemu_cpu_kick(penv);
 961         penv = (CPUState *)penv->next_cpu;
 962     }
 963 }
 964
 965 static void qemu_tcg_init_vcpu(void *_env)
 966 {
 967     CPUState *env = _env;
 968
 969     /* share a single thread for all cpus with TCG */
 970     if (!tcg_cpu_thread) {
 971         env->thread = g_malloc0(sizeof(QemuThread));
 972         env->halt_cond = g_malloc0(sizeof(QemuCond));
 973         qemu_cond_init(env->halt_cond);
 974         qemu_thread_create(env->thread, qemu_tcg_cpu_thread_fn, env);
 975         while (env->created == 0) {
 976             qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
 977         }
 978         tcg_cpu_thread = env->thread;
 979         tcg_halt_cond = env->halt_cond;
 980     } else {
 981         env->thread = tcg_cpu_thread;
 982         env->halt_cond = tcg_halt_cond;
 983     }
 984 }
 985
 986 static void qemu_kvm_start_vcpu(CPUState *env)
 987 {
 988     env->thread = g_malloc0(sizeof(QemuThread));
 989     env->halt_cond = g_malloc0(sizeof(QemuCond));
 990     qemu_cond_init(env->halt_cond);
 991     qemu_thread_create(env->thread, qemu_kvm_cpu_thread_fn, env);
 992     while (env->created == 0) {
 993         qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
 994     }
 995 }
 996
 997 void qemu_init_vcpu(void *_env)
 998 {
 999     CPUState *env = _env;
1000
1001     env->nr_cores = smp_cores;
1002     env->nr_threads = smp_threads;
1003     if (kvm_enabled()) {
1004         qemu_kvm_start_vcpu(env);
1005     } else {
1006         qemu_tcg_init_vcpu(env);
1007     }
1008 }
1009
1010 void qemu_notify_event(void)
1011 {
1012     qemu_event_increment();
1013 }
1014
1015 void cpu_stop_current(void)
1016 {
1017     if (cpu_single_env) {
1018         cpu_single_env->stop = 0;
1019         cpu_single_env->stopped = 1;
1020         cpu_exit(cpu_single_env);
1021         qemu_cond_signal(&qemu_pause_cond);
1022     }
1023 }
1024
1025 void vm_stop(int reason)
1026 {
1027     if (!qemu_thread_is_self(&io_thread)) {
1028         qemu_system_vmstop_request(reason);
1029         /*
1030          * FIXME: should not return to device code in case
1031          * vm_stop() has been requested.
1032          */
1033         cpu_stop_current();
1034         return;
1035     }
1036     do_vm_stop(reason);
1037 }
1038
1039 #endif
1040
1041 static int tcg_cpu_exec(CPUState *env)
1042 {
1043     int ret;
1044 #ifdef CONFIG_PROFILER
1045     int64_t ti;
1046 #endif
1047
1048 #ifdef CONFIG_PROFILER
1049     ti = profile_getclock();
1050 #endif
1051     if (use_icount) {
1052         int64_t count;
1053         int decr;
1054         qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
1055         env->icount_decr.u16.low = 0;
1056         env->icount_extra = 0;
1057         count = qemu_icount_round(qemu_next_icount_deadline());
1058         qemu_icount += count;
1059         decr = (count > 0xffff) ? 0xffff : count;
1060         count -= decr;
1061         env->icount_decr.u16.low = decr;
1062         env->icount_extra = count;
1063     }
1064     ret = cpu_exec(env);
1065 #ifdef CONFIG_PROFILER
1066     qemu_time += profile_getclock() - ti;
1067 #endif
1068     if (use_icount) {
1069         /* Fold pending instructions back into the
1070            instruction counter, and clear the interrupt flag.  */
1071         qemu_icount -= (env->icount_decr.u16.low
1072                         + env->icount_extra);
1073         env->icount_decr.u32 = 0;
1074         env->icount_extra = 0;
1075     }
1076     return ret;
1077 }
1078
1079 bool cpu_exec_all(void)
1080 {
1081     int r;
1082
1083     /* Account partial waits to the vm_clock.  */
1084     qemu_clock_warp(vm_clock);
1085
1086     if (next_cpu == NULL) {
1087         next_cpu = first_cpu;
1088     }
1089     for (; next_cpu != NULL && !exit_request; next_cpu = next_cpu->next_cpu) {
1090         CPUState *env = next_cpu;
1091
1092         qemu_clock_enable(vm_clock,
1093                           (env->singlestep_enabled & SSTEP_NOTIMER) == 0);
1094
1095 #ifndef CONFIG_IOTHREAD
1096         if (qemu_alarm_pending()) {
1097             break;
1098         }
1099 #endif
1100         if (cpu_can_run(env)) {
1101             if (kvm_enabled()) {
1102                 r = kvm_cpu_exec(env);
1103                 qemu_kvm_eat_signals(env);
1104             } else {
1105                 r = tcg_cpu_exec(env);
1106             }
1107             if (r == EXCP_DEBUG) {
1108                 cpu_handle_guest_debug(env);
1109                 break;
1110             }
1111         } else if (env->stop || env->stopped) {
1112             break;
1113         }
1114     }
1115     exit_request = 0;
1116     return !all_cpu_threads_idle();
1117 }
1118
1119 void set_numa_modes(void)
1120 {
1121     CPUState *env;
1122     int i;
1123
1124     for (env = first_cpu; env != NULL; env = env->next_cpu) {
1125         for (i = 0; i < nb_numa_nodes; i++) {
1126             if (node_cpumask[i] & (1 << env->cpu_index)) {
1127                 env->numa_node = i;
1128             }
1129         }
1130     }
1131 }
1132
1133 void set_cpu_log(const char *optarg)
1134 {
1135     int mask;
1136     const CPULogItem *item;
1137
1138     mask = cpu_str_to_log_mask(optarg);
1139     if (!mask) {
1140         printf("Log items (comma separated):\n");
1141         for (item = cpu_log_items; item->mask != 0; item++) {
1142             printf("%-10s %s\n", item->name, item->help);
1143         }
1144         exit(1);
1145     }
1146     cpu_set_log(mask);
1147 }
1148
1149 void set_cpu_log_filename(const char *optarg)
1150 {
1151     cpu_set_log_filename(optarg);
1152 }
1153
1154 /* Return the virtual CPU time, based on the instruction counter.  */
1155 int64_t cpu_get_icount(void)
1156 {
1157     int64_t icount;
1158     CPUState *env = cpu_single_env;;
1159
1160     icount = qemu_icount;
1161     if (env) {
1162         if (!can_do_io(env)) {
1163             fprintf(stderr, "Bad clock read\n");
1164         }
1165         icount -= (env->icount_decr.u16.low + env->icount_extra);
1166     }
1167     return qemu_icount_bias + (icount << icount_time_shift);
1168 }
1169
1170 void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
1171 {
1172     /* XXX: implement xxx_cpu_list for targets that still miss it */
1173 #if defined(cpu_list_id)
1174     cpu_list_id(f, cpu_fprintf, optarg);
1175 #elif defined(cpu_list)
1176     cpu_list(f, cpu_fprintf); /* deprecated */
1177 #endif
1178 }