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