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 !runstate_is_running() || env->stopped;
 119 }
 120
 121 static void do_vm_stop(RunState state)
 122 {
 123     if (runstate_is_running()) {
 124         cpu_disable_ticks();
 125         pause_all_vcpus();
 126         runstate_set(state);
 127         vm_state_notify(0, state);
 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 || !runstate_is_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 || !runstate_is_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     env->stopped = 1;
 177 }
 178
 179 static void cpu_signal(int sig)
 180 {
 181     if (cpu_single_env) {
 182         cpu_exit(cpu_single_env);
 183     }
 184     exit_request = 1;
 185 }
 186
 187 #ifdef CONFIG_LINUX
 188 static void sigbus_reraise(void)
 189 {
 190     sigset_t set;
 191     struct sigaction action;
 192
 193     memset(&action, 0, sizeof(action));
 194     action.sa_handler = SIG_DFL;
 195     if (!sigaction(SIGBUS, &action, NULL)) {
 196         raise(SIGBUS);
 197         sigemptyset(&set);
 198         sigaddset(&set, SIGBUS);
 199         sigprocmask(SIG_UNBLOCK, &set, NULL);
 200     }
 201     perror("Failed to re-raise SIGBUS!\n");
 202     abort();
 203 }
 204
 205 static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo,
 206                            void *ctx)
 207 {
 208     if (kvm_on_sigbus(siginfo->ssi_code,
 209                       (void *)(intptr_t)siginfo->ssi_addr)) {
 210         sigbus_reraise();
 211     }
 212 }
 213
 214 static void qemu_init_sigbus(void)
 215 {
 216     struct sigaction action;
 217
 218     memset(&action, 0, sizeof(action));
 219     action.sa_flags = SA_SIGINFO;
 220     action.sa_sigaction = (void (*)(int, siginfo_t*, void*))sigbus_handler;
 221     sigaction(SIGBUS, &action, NULL);
 222
 223     prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, 0, 0);
 224 }
 225
 226 static void qemu_kvm_eat_signals(CPUState *env)
 227 {
 228     struct timespec ts = { 0, 0 };
 229     siginfo_t siginfo;
 230     sigset_t waitset;
 231     sigset_t chkset;
 232     int r;
 233
 234     sigemptyset(&waitset);
 235     sigaddset(&waitset, SIG_IPI);
 236     sigaddset(&waitset, SIGBUS);
 237
 238     do {
 239         r = sigtimedwait(&waitset, &siginfo, &ts);
 240         if (r == -1 && !(errno == EAGAIN || errno == EINTR)) {
 241             perror("sigtimedwait");
 242             exit(1);
 243         }
 244
 245         switch (r) {
 246         case SIGBUS:
 247             if (kvm_on_sigbus_vcpu(env, siginfo.si_code, siginfo.si_addr)) {
 248                 sigbus_reraise();
 249             }
 250             break;
 251         default:
 252             break;
 253         }
 254
 255         r = sigpending(&chkset);
 256         if (r == -1) {
 257             perror("sigpending");
 258             exit(1);
 259         }
 260     } while (sigismember(&chkset, SIG_IPI) || sigismember(&chkset, SIGBUS));
 261 }
 262
 263 #else /* !CONFIG_LINUX */
 264
 265 static void qemu_init_sigbus(void)
 266 {
 267 }
 268
 269 static void qemu_kvm_eat_signals(CPUState *env)
 270 {
 271 }
 272 #endif /* !CONFIG_LINUX */
 273
 274 #ifndef _WIN32
 275 static int io_thread_fd = -1;
 276
 277 static void qemu_event_increment(void)
 278 {
 279     /* Write 8 bytes to be compatible with eventfd.  */
 280     static const uint64_t val = 1;
 281     ssize_t ret;
 282
 283     if (io_thread_fd == -1) {
 284         return;
 285     }
 286     do {
 287         ret = write(io_thread_fd, &val, sizeof(val));
 288     } while (ret < 0 && errno == EINTR);
 289
 290     /* EAGAIN is fine, a read must be pending.  */
 291     if (ret < 0 && errno != EAGAIN) {
 292         fprintf(stderr, "qemu_event_increment: write() failed: %s\n",
 293                 strerror(errno));
 294         exit (1);
 295     }
 296 }
 297
 298 static void qemu_event_read(void *opaque)
 299 {
 300     int fd = (intptr_t)opaque;
 301     ssize_t len;
 302     char buffer[512];
 303
 304     /* Drain the notify pipe.  For eventfd, only 8 bytes will be read.  */
 305     do {
 306         len = read(fd, buffer, sizeof(buffer));
 307     } while ((len == -1 && errno == EINTR) || len == sizeof(buffer));
 308 }
 309
 310 static int qemu_event_init(void)
 311 {
 312     int err;
 313     int fds[2];
 314
 315     err = qemu_eventfd(fds);
 316     if (err == -1) {
 317         return -errno;
 318     }
 319     err = fcntl_setfl(fds[0], O_NONBLOCK);
 320     if (err < 0) {
 321         goto fail;
 322     }
 323     err = fcntl_setfl(fds[1], O_NONBLOCK);
 324     if (err < 0) {
 325         goto fail;
 326     }
 327     qemu_set_fd_handler2(fds[0], NULL, qemu_event_read, NULL,
 328                          (void *)(intptr_t)fds[0]);
 329
 330     io_thread_fd = fds[1];
 331     return 0;
 332
 333 fail:
 334     close(fds[0]);
 335     close(fds[1]);
 336     return err;
 337 }
 338
 339 static void dummy_signal(int sig)
 340 {
 341 }
 342
 343 /* If we have signalfd, we mask out the signals we want to handle and then
 344  * use signalfd to listen for them.  We rely on whatever the current signal
 345  * handler is to dispatch the signals when we receive them.
 346  */
 347 static void sigfd_handler(void *opaque)
 348 {
 349     int fd = (intptr_t)opaque;
 350     struct qemu_signalfd_siginfo info;
 351     struct sigaction action;
 352     ssize_t len;
 353
 354     while (1) {
 355         do {
 356             len = read(fd, &info, sizeof(info));
 357         } while (len == -1 && errno == EINTR);
 358
 359         if (len == -1 && errno == EAGAIN) {
 360             break;
 361         }
 362
 363         if (len != sizeof(info)) {
 364             printf("read from sigfd returned %zd: %m\n", len);
 365             return;
 366         }
 367
 368         sigaction(info.ssi_signo, NULL, &action);
 369         if ((action.sa_flags & SA_SIGINFO) && action.sa_sigaction) {
 370             action.sa_sigaction(info.ssi_signo,
 371                                 (siginfo_t *)&info, NULL);
 372         } else if (action.sa_handler) {
 373             action.sa_handler(info.ssi_signo);
 374         }
 375     }
 376 }
 377
 378 static int qemu_signal_init(void)
 379 {
 380     int sigfd;
 381     sigset_t set;
 382
 383     /*
 384      * SIG_IPI must be blocked in the main thread and must not be caught
 385      * by sigwait() in the signal thread. Otherwise, the cpu thread will
 386      * not catch it reliably.
 387      */
 388     sigemptyset(&set);
 389     sigaddset(&set, SIG_IPI);
 390     pthread_sigmask(SIG_BLOCK, &set, NULL);
 391
 392     sigemptyset(&set);
 393     sigaddset(&set, SIGIO);
 394     sigaddset(&set, SIGALRM);
 395     sigaddset(&set, SIGBUS);
 396     pthread_sigmask(SIG_BLOCK, &set, NULL);
 397
 398     sigfd = qemu_signalfd(&set);
 399     if (sigfd == -1) {
 400         fprintf(stderr, "failed to create signalfd\n");
 401         return -errno;
 402     }
 403
 404     fcntl_setfl(sigfd, O_NONBLOCK);
 405
 406     qemu_set_fd_handler2(sigfd, NULL, sigfd_handler, NULL,
 407                          (void *)(intptr_t)sigfd);
 408
 409     return 0;
 410 }
 411
 412 static void qemu_kvm_init_cpu_signals(CPUState *env)
 413 {
 414     int r;
 415     sigset_t set;
 416     struct sigaction sigact;
 417
 418     memset(&sigact, 0, sizeof(sigact));
 419     sigact.sa_handler = dummy_signal;
 420     sigaction(SIG_IPI, &sigact, NULL);
 421
 422     pthread_sigmask(SIG_BLOCK, NULL, &set);
 423     sigdelset(&set, SIG_IPI);
 424     sigdelset(&set, SIGBUS);
 425     r = kvm_set_signal_mask(env, &set);
 426     if (r) {
 427         fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));
 428         exit(1);
 429     }
 430
 431     sigdelset(&set, SIG_IPI);
 432     sigdelset(&set, SIGBUS);
 433     r = kvm_set_signal_mask(env, &set);
 434     if (r) {
 435         fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));
 436         exit(1);
 437     }
 438 }
 439
 440 static void qemu_tcg_init_cpu_signals(void)
 441 {
 442     sigset_t set;
 443     struct sigaction sigact;
 444
 445     memset(&sigact, 0, sizeof(sigact));
 446     sigact.sa_handler = cpu_signal;
 447     sigaction(SIG_IPI, &sigact, NULL);
 448
 449     sigemptyset(&set);
 450     sigaddset(&set, SIG_IPI);
 451     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
 452 }
 453
 454 #else /* _WIN32 */
 455
 456 HANDLE qemu_event_handle;
 457
 458 static void dummy_event_handler(void *opaque)
 459 {
 460 }
 461
 462 static int qemu_event_init(void)
 463 {
 464     qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
 465     if (!qemu_event_handle) {
 466         fprintf(stderr, "Failed CreateEvent: %ld\n", GetLastError());
 467         return -1;
 468     }
 469     qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
 470     return 0;
 471 }
 472
 473 static void qemu_event_increment(void)
 474 {
 475     if (!SetEvent(qemu_event_handle)) {
 476         fprintf(stderr, "qemu_event_increment: SetEvent failed: %ld\n",
 477                 GetLastError());
 478         exit (1);
 479     }
 480 }
 481
 482 static int qemu_signal_init(void)
 483 {
 484     return 0;
 485 }
 486
 487 static void qemu_kvm_init_cpu_signals(CPUState *env)
 488 {
 489     abort();
 490 }
 491
 492 static void qemu_tcg_init_cpu_signals(void)
 493 {
 494 }
 495 #endif /* _WIN32 */
 496
 497 QemuMutex qemu_global_mutex;
 498 static QemuCond qemu_io_proceeded_cond;
 499 static bool iothread_requesting_mutex;
 500
 501 static QemuThread io_thread;
 502
 503 static QemuThread *tcg_cpu_thread;
 504 static QemuCond *tcg_halt_cond;
 505
 506 /* cpu creation */
 507 static QemuCond qemu_cpu_cond;
 508 /* system init */
 509 static QemuCond qemu_pause_cond;
 510 static QemuCond qemu_work_cond;
 511
 512 int qemu_init_main_loop(void)
 513 {
 514     int ret;
 515
 516     qemu_init_sigbus();
 517
 518     ret = qemu_signal_init();
 519     if (ret) {
 520         return ret;
 521     }
 522
 523     /* Note eventfd must be drained before signalfd handlers run */
 524     ret = qemu_event_init();
 525     if (ret) {
 526         return ret;
 527     }
 528
 529     qemu_cond_init(&qemu_cpu_cond);
 530     qemu_cond_init(&qemu_pause_cond);
 531     qemu_cond_init(&qemu_work_cond);
 532     qemu_cond_init(&qemu_io_proceeded_cond);
 533     qemu_mutex_init(&qemu_global_mutex);
 534     qemu_mutex_lock(&qemu_global_mutex);
 535
 536     qemu_thread_get_self(&io_thread);
 537
 538     return 0;
 539 }
 540
 541 void qemu_main_loop_start(void)
 542 {
 543     resume_all_vcpus();
 544 }
 545
 546 void run_on_cpu(CPUState *env, void (*func)(void *data), void *data)
 547 {
 548     struct qemu_work_item wi;
 549
 550     if (qemu_cpu_is_self(env)) {
 551         func(data);
 552         return;
 553     }
 554
 555     wi.func = func;
 556     wi.data = data;
 557     if (!env->queued_work_first) {
 558         env->queued_work_first = &wi;
 559     } else {
 560         env->queued_work_last->next = &wi;
 561     }
 562     env->queued_work_last = &wi;
 563     wi.next = NULL;
 564     wi.done = false;
 565
 566     qemu_cpu_kick(env);
 567     while (!wi.done) {
 568         CPUState *self_env = cpu_single_env;
 569
 570         qemu_cond_wait(&qemu_work_cond, &qemu_global_mutex);
 571         cpu_single_env = self_env;
 572     }
 573 }
 574
 575 static void flush_queued_work(CPUState *env)
 576 {
 577     struct qemu_work_item *wi;
 578
 579     if (!env->queued_work_first) {
 580         return;
 581     }
 582
 583     while ((wi = env->queued_work_first)) {
 584         env->queued_work_first = wi->next;
 585         wi->func(wi->data);
 586         wi->done = true;
 587     }
 588     env->queued_work_last = NULL;
 589     qemu_cond_broadcast(&qemu_work_cond);
 590 }
 591
 592 static void qemu_wait_io_event_common(CPUState *env)
 593 {
 594     if (env->stop) {
 595         env->stop = 0;
 596         env->stopped = 1;
 597         qemu_cond_signal(&qemu_pause_cond);
 598     }
 599     flush_queued_work(env);
 600     env->thread_kicked = false;
 601 }
 602
 603 static void qemu_tcg_wait_io_event(void)
 604 {
 605     CPUState *env;
 606
 607     while (all_cpu_threads_idle()) {
 608        /* Start accounting real time to the virtual clock if the CPUs
 609           are idle.  */
 610         qemu_clock_warp(vm_clock);
 611         qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
 612     }
 613
 614     while (iothread_requesting_mutex) {
 615         qemu_cond_wait(&qemu_io_proceeded_cond, &qemu_global_mutex);
 616     }
 617
 618     for (env = first_cpu; env != NULL; env = env->next_cpu) {
 619         qemu_wait_io_event_common(env);
 620     }
 621 }
 622
 623 static void qemu_kvm_wait_io_event(CPUState *env)
 624 {
 625     while (cpu_thread_is_idle(env)) {
 626         qemu_cond_wait(env->halt_cond, &qemu_global_mutex);
 627     }
 628
 629     qemu_kvm_eat_signals(env);
 630     qemu_wait_io_event_common(env);
 631 }
 632
 633 static void *qemu_kvm_cpu_thread_fn(void *arg)
 634 {
 635     CPUState *env = arg;
 636     int r;
 637
 638     qemu_mutex_lock(&qemu_global_mutex);
 639     qemu_thread_get_self(env->thread);
 640     env->thread_id = qemu_get_thread_id();
 641
 642     r = kvm_init_vcpu(env);
 643     if (r < 0) {
 644         fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r));
 645         exit(1);
 646     }
 647
 648     qemu_kvm_init_cpu_signals(env);
 649
 650     /* signal CPU creation */
 651     env->created = 1;
 652     qemu_cond_signal(&qemu_cpu_cond);
 653
 654     while (1) {
 655         if (cpu_can_run(env)) {
 656             r = kvm_cpu_exec(env);
 657             if (r == EXCP_DEBUG) {
 658                 cpu_handle_guest_debug(env);
 659             }
 660         }
 661         qemu_kvm_wait_io_event(env);
 662     }
 663
 664     return NULL;
 665 }
 666
 667 static void *qemu_tcg_cpu_thread_fn(void *arg)
 668 {
 669     CPUState *env = arg;
 670
 671     qemu_tcg_init_cpu_signals();
 672     qemu_thread_get_self(env->thread);
 673
 674     /* signal CPU creation */
 675     qemu_mutex_lock(&qemu_global_mutex);
 676     for (env = first_cpu; env != NULL; env = env->next_cpu) {
 677         env->thread_id = qemu_get_thread_id();
 678         env->created = 1;
 679     }
 680     qemu_cond_signal(&qemu_cpu_cond);
 681
 682     /* wait for initial kick-off after machine start */
 683     while (first_cpu->stopped) {
 684         qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
 685     }
 686
 687     while (1) {
 688         cpu_exec_all();
 689         if (use_icount && qemu_next_icount_deadline() <= 0) {
 690             qemu_notify_event();
 691         }
 692         qemu_tcg_wait_io_event();
 693     }
 694
 695     return NULL;
 696 }
 697
 698 static void qemu_cpu_kick_thread(CPUState *env)
 699 {
 700 #ifndef _WIN32
 701     int err;
 702
 703     err = pthread_kill(env->thread->thread, SIG_IPI);
 704     if (err) {
 705         fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
 706         exit(1);
 707     }
 708 #else /* _WIN32 */
 709     if (!qemu_cpu_is_self(env)) {
 710         SuspendThread(env->thread->thread);
 711         cpu_signal(0);
 712         ResumeThread(env->thread->thread);
 713     }
 714 #endif
 715 }
 716
 717 void qemu_cpu_kick(void *_env)
 718 {
 719     CPUState *env = _env;
 720
 721     qemu_cond_broadcast(env->halt_cond);
 722     if (kvm_enabled() && !env->thread_kicked) {
 723         qemu_cpu_kick_thread(env);
 724         env->thread_kicked = true;
 725     }
 726 }
 727
 728 void qemu_cpu_kick_self(void)
 729 {
 730 #ifndef _WIN32
 731     assert(cpu_single_env);
 732
 733     if (!cpu_single_env->thread_kicked) {
 734         qemu_cpu_kick_thread(cpu_single_env);
 735         cpu_single_env->thread_kicked = true;
 736     }
 737 #else
 738     abort();
 739 #endif
 740 }
 741
 742 int qemu_cpu_is_self(void *_env)
 743 {
 744     CPUState *env = _env;
 745
 746     return qemu_thread_is_self(env->thread);
 747 }
 748
 749 void qemu_mutex_lock_iothread(void)
 750 {
 751     if (kvm_enabled()) {
 752         qemu_mutex_lock(&qemu_global_mutex);
 753     } else {
 754         iothread_requesting_mutex = true;
 755         if (qemu_mutex_trylock(&qemu_global_mutex)) {
 756             qemu_cpu_kick_thread(first_cpu);
 757             qemu_mutex_lock(&qemu_global_mutex);
 758         }
 759         iothread_requesting_mutex = false;
 760         qemu_cond_broadcast(&qemu_io_proceeded_cond);
 761     }
 762 }
 763
 764 void qemu_mutex_unlock_iothread(void)
 765 {
 766     qemu_mutex_unlock(&qemu_global_mutex);
 767 }
 768
 769 static int all_vcpus_paused(void)
 770 {
 771     CPUState *penv = first_cpu;
 772
 773     while (penv) {
 774         if (!penv->stopped) {
 775             return 0;
 776         }
 777         penv = (CPUState *)penv->next_cpu;
 778     }
 779
 780     return 1;
 781 }
 782
 783 void pause_all_vcpus(void)
 784 {
 785     CPUState *penv = first_cpu;
 786
 787     while (penv) {
 788         penv->stop = 1;
 789         qemu_cpu_kick(penv);
 790         penv = (CPUState *)penv->next_cpu;
 791     }
 792
 793     while (!all_vcpus_paused()) {
 794         qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
 795         penv = first_cpu;
 796         while (penv) {
 797             qemu_cpu_kick(penv);
 798             penv = (CPUState *)penv->next_cpu;
 799         }
 800     }
 801 }
 802
 803 void resume_all_vcpus(void)
 804 {
 805     CPUState *penv = first_cpu;
 806
 807     while (penv) {
 808         penv->stop = 0;
 809         penv->stopped = 0;
 810         qemu_cpu_kick(penv);
 811         penv = (CPUState *)penv->next_cpu;
 812     }
 813 }
 814
 815 static void qemu_tcg_init_vcpu(void *_env)
 816 {
 817     CPUState *env = _env;
 818
 819     /* share a single thread for all cpus with TCG */
 820     if (!tcg_cpu_thread) {
 821         env->thread = g_malloc0(sizeof(QemuThread));
 822         env->halt_cond = g_malloc0(sizeof(QemuCond));
 823         qemu_cond_init(env->halt_cond);
 824         tcg_halt_cond = env->halt_cond;
 825         qemu_thread_create(env->thread, qemu_tcg_cpu_thread_fn, env);
 826         while (env->created == 0) {
 827             qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
 828         }
 829         tcg_cpu_thread = env->thread;
 830     } else {
 831         env->thread = tcg_cpu_thread;
 832         env->halt_cond = tcg_halt_cond;
 833     }
 834 }
 835
 836 static void qemu_kvm_start_vcpu(CPUState *env)
 837 {
 838     env->thread = g_malloc0(sizeof(QemuThread));
 839     env->halt_cond = g_malloc0(sizeof(QemuCond));
 840     qemu_cond_init(env->halt_cond);
 841     qemu_thread_create(env->thread, qemu_kvm_cpu_thread_fn, env);
 842     while (env->created == 0) {
 843         qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
 844     }
 845 }
 846
 847 void qemu_init_vcpu(void *_env)
 848 {
 849     CPUState *env = _env;
 850
 851     env->nr_cores = smp_cores;
 852     env->nr_threads = smp_threads;
 853     env->stopped = 1;
 854     if (kvm_enabled()) {
 855         qemu_kvm_start_vcpu(env);
 856     } else {
 857         qemu_tcg_init_vcpu(env);
 858     }
 859 }
 860
 861 void qemu_notify_event(void)
 862 {
 863     qemu_event_increment();
 864 }
 865
 866 void cpu_stop_current(void)
 867 {
 868     if (cpu_single_env) {
 869         cpu_single_env->stop = 0;
 870         cpu_single_env->stopped = 1;
 871         cpu_exit(cpu_single_env);
 872         qemu_cond_signal(&qemu_pause_cond);
 873     }
 874 }
 875
 876 void vm_stop(RunState state)
 877 {
 878     if (!qemu_thread_is_self(&io_thread)) {
 879         qemu_system_vmstop_request(state);
 880         /*
 881          * FIXME: should not return to device code in case
 882          * vm_stop() has been requested.
 883          */
 884         cpu_stop_current();
 885         return;
 886     }
 887     do_vm_stop(state);
 888 }
 889
 890 static int tcg_cpu_exec(CPUState *env)
 891 {
 892     int ret;
 893 #ifdef CONFIG_PROFILER
 894     int64_t ti;
 895 #endif
 896
 897 #ifdef CONFIG_PROFILER
 898     ti = profile_getclock();
 899 #endif
 900     if (use_icount) {
 901         int64_t count;
 902         int decr;
 903         qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
 904         env->icount_decr.u16.low = 0;
 905         env->icount_extra = 0;
 906         count = qemu_icount_round(qemu_next_icount_deadline());
 907         qemu_icount += count;
 908         decr = (count > 0xffff) ? 0xffff : count;
 909         count -= decr;
 910         env->icount_decr.u16.low = decr;
 911         env->icount_extra = count;
 912     }
 913     ret = cpu_exec(env);
 914 #ifdef CONFIG_PROFILER
 915     qemu_time += profile_getclock() - ti;
 916 #endif
 917     if (use_icount) {
 918         /* Fold pending instructions back into the
 919            instruction counter, and clear the interrupt flag.  */
 920         qemu_icount -= (env->icount_decr.u16.low
 921                         + env->icount_extra);
 922         env->icount_decr.u32 = 0;
 923         env->icount_extra = 0;
 924     }
 925     return ret;
 926 }
 927
 928 bool cpu_exec_all(void)
 929 {
 930     int r;
 931
 932     /* Account partial waits to the vm_clock.  */
 933     qemu_clock_warp(vm_clock);
 934
 935     if (next_cpu == NULL) {
 936         next_cpu = first_cpu;
 937     }
 938     for (; next_cpu != NULL && !exit_request; next_cpu = next_cpu->next_cpu) {
 939         CPUState *env = next_cpu;
 940
 941         qemu_clock_enable(vm_clock,
 942                           (env->singlestep_enabled & SSTEP_NOTIMER) == 0);
 943
 944         if (cpu_can_run(env)) {
 945             if (kvm_enabled()) {
 946                 r = kvm_cpu_exec(env);
 947                 qemu_kvm_eat_signals(env);
 948             } else {
 949                 r = tcg_cpu_exec(env);
 950             }
 951             if (r == EXCP_DEBUG) {
 952                 cpu_handle_guest_debug(env);
 953                 break;
 954             }
 955         } else if (env->stop || env->stopped) {
 956             break;
 957         }
 958     }
 959     exit_request = 0;
 960     return !all_cpu_threads_idle();
 961 }
 962
 963 void set_numa_modes(void)
 964 {
 965     CPUState *env;
 966     int i;
 967
 968     for (env = first_cpu; env != NULL; env = env->next_cpu) {
 969         for (i = 0; i < nb_numa_nodes; i++) {
 970             if (node_cpumask[i] & (1 << env->cpu_index)) {
 971                 env->numa_node = i;
 972             }
 973         }
 974     }
 975 }
 976
 977 void set_cpu_log(const char *optarg)
 978 {
 979     int mask;
 980     const CPULogItem *item;
 981
 982     mask = cpu_str_to_log_mask(optarg);
 983     if (!mask) {
 984         printf("Log items (comma separated):\n");
 985         for (item = cpu_log_items; item->mask != 0; item++) {
 986             printf("%-10s %s\n", item->name, item->help);
 987         }
 988         exit(1);
 989     }
 990     cpu_set_log(mask);
 991 }
 992
 993 void set_cpu_log_filename(const char *optarg)
 994 {
 995     cpu_set_log_filename(optarg);
 996 }
 997
 998 /* Return the virtual CPU time, based on the instruction counter.  */
 999 int64_t cpu_get_icount(void)
1000 {
1001     int64_t icount;
1002     CPUState *env = cpu_single_env;;
1003
1004     icount = qemu_icount;
1005     if (env) {
1006         if (!can_do_io(env)) {
1007             fprintf(stderr, "Bad clock read\n");
1008         }
1009         icount -= (env->icount_decr.u16.low + env->icount_extra);
1010     }
1011     return qemu_icount_bias + (icount << icount_time_shift);
1012 }
1013
1014 void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
1015 {
1016     /* XXX: implement xxx_cpu_list for targets that still miss it */
1017 #if defined(cpu_list_id)
1018     cpu_list_id(f, cpu_fprintf, optarg);
1019 #elif defined(cpu_list)
1020     cpu_list(f, cpu_fprintf); /* deprecated */
1021 #endif
1022 }