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 "qmp-commands.h"
  34
  35 #include "qemu-thread.h"
  36 #include "cpus.h"
  37 #include "qtest.h"
  38 #include "main-loop.h"
  39 #include "bitmap.h"
  40
  41 #ifndef _WIN32
  42 #include "compatfd.h"
  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 CPUArchState *next_cpu;
  64
  65 static bool cpu_thread_is_idle(CPUArchState *env)
  66 {
  67     if (env->stop || env->queued_work_first) {
  68         return false;
  69     }
  70     if (env->stopped || !runstate_is_running()) {
  71         return true;
  72     }
  73     if (!env->halted || qemu_cpu_has_work(env) ||
  74         kvm_async_interrupts_enabled()) {
  75         return false;
  76     }
  77     return true;
  78 }
  79
  80 static bool all_cpu_threads_idle(void)
  81 {
  82     CPUArchState *env;
  83
  84     for (env = first_cpu; env != NULL; env = env->next_cpu) {
  85         if (!cpu_thread_is_idle(env)) {
  86             return false;
  87         }
  88     }
  89     return true;
  90 }
  91
  92 /***********************************************************/
  93 /* guest cycle counter */
  94
  95 /* Conversion factor from emulated instructions to virtual clock ticks.  */
  96 static int icount_time_shift;
  97 /* Arbitrarily pick 1MIPS as the minimum allowable speed.  */
  98 #define MAX_ICOUNT_SHIFT 10
  99 /* Compensate for varying guest execution speed.  */
 100 static int64_t qemu_icount_bias;
 101 static QEMUTimer *icount_rt_timer;
 102 static QEMUTimer *icount_vm_timer;
 103 static QEMUTimer *icount_warp_timer;
 104 static int64_t vm_clock_warp_start;
 105 static int64_t qemu_icount;
 106
 107 typedef struct TimersState {
 108     int64_t cpu_ticks_prev;
 109     int64_t cpu_ticks_offset;
 110     int64_t cpu_clock_offset;
 111     int32_t cpu_ticks_enabled;
 112     int64_t dummy;
 113 } TimersState;
 114
 115 TimersState timers_state;
 116
 117 /* Return the virtual CPU time, based on the instruction counter.  */
 118 int64_t cpu_get_icount(void)
 119 {
 120     int64_t icount;
 121     CPUArchState *env = cpu_single_env;
 122
 123     icount = qemu_icount;
 124     if (env) {
 125         if (!can_do_io(env)) {
 126             fprintf(stderr, "Bad clock read\n");
 127         }
 128         icount -= (env->icount_decr.u16.low + env->icount_extra);
 129     }
 130     return qemu_icount_bias + (icount << icount_time_shift);
 131 }
 132
 133 /* return the host CPU cycle counter and handle stop/restart */
 134 int64_t cpu_get_ticks(void)
 135 {
 136     if (use_icount) {
 137         return cpu_get_icount();
 138     }
 139     if (!timers_state.cpu_ticks_enabled) {
 140         return timers_state.cpu_ticks_offset;
 141     } else {
 142         int64_t ticks;
 143         ticks = cpu_get_real_ticks();
 144         if (timers_state.cpu_ticks_prev > ticks) {
 145             /* Note: non increasing ticks may happen if the host uses
 146                software suspend */
 147             timers_state.cpu_ticks_offset += timers_state.cpu_ticks_prev - ticks;
 148         }
 149         timers_state.cpu_ticks_prev = ticks;
 150         return ticks + timers_state.cpu_ticks_offset;
 151     }
 152 }
 153
 154 /* return the host CPU monotonic timer and handle stop/restart */
 155 int64_t cpu_get_clock(void)
 156 {
 157     int64_t ti;
 158     if (!timers_state.cpu_ticks_enabled) {
 159         return timers_state.cpu_clock_offset;
 160     } else {
 161         ti = get_clock();
 162         return ti + timers_state.cpu_clock_offset;
 163     }
 164 }
 165
 166 /* enable cpu_get_ticks() */
 167 void cpu_enable_ticks(void)
 168 {
 169     if (!timers_state.cpu_ticks_enabled) {
 170         timers_state.cpu_ticks_offset -= cpu_get_real_ticks();
 171         timers_state.cpu_clock_offset -= get_clock();
 172         timers_state.cpu_ticks_enabled = 1;
 173     }
 174 }
 175
 176 /* disable cpu_get_ticks() : the clock is stopped. You must not call
 177    cpu_get_ticks() after that.  */
 178 void cpu_disable_ticks(void)
 179 {
 180     if (timers_state.cpu_ticks_enabled) {
 181         timers_state.cpu_ticks_offset = cpu_get_ticks();
 182         timers_state.cpu_clock_offset = cpu_get_clock();
 183         timers_state.cpu_ticks_enabled = 0;
 184     }
 185 }
 186
 187 /* Correlation between real and virtual time is always going to be
 188    fairly approximate, so ignore small variation.
 189    When the guest is idle real and virtual time will be aligned in
 190    the IO wait loop.  */
 191 #define ICOUNT_WOBBLE (get_ticks_per_sec() / 10)
 192
 193 static void icount_adjust(void)
 194 {
 195     int64_t cur_time;
 196     int64_t cur_icount;
 197     int64_t delta;
 198     static int64_t last_delta;
 199     /* If the VM is not running, then do nothing.  */
 200     if (!runstate_is_running()) {
 201         return;
 202     }
 203     cur_time = cpu_get_clock();
 204     cur_icount = qemu_get_clock_ns(vm_clock);
 205     delta = cur_icount - cur_time;
 206     /* FIXME: This is a very crude algorithm, somewhat prone to oscillation.  */
 207     if (delta > 0
 208         && last_delta + ICOUNT_WOBBLE < delta * 2
 209         && icount_time_shift > 0) {
 210         /* The guest is getting too far ahead.  Slow time down.  */
 211         icount_time_shift--;
 212     }
 213     if (delta < 0
 214         && last_delta - ICOUNT_WOBBLE > delta * 2
 215         && icount_time_shift < MAX_ICOUNT_SHIFT) {
 216         /* The guest is getting too far behind.  Speed time up.  */
 217         icount_time_shift++;
 218     }
 219     last_delta = delta;
 220     qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
 221 }
 222
 223 static void icount_adjust_rt(void *opaque)
 224 {
 225     qemu_mod_timer(icount_rt_timer,
 226                    qemu_get_clock_ms(rt_clock) + 1000);
 227     icount_adjust();
 228 }
 229
 230 static void icount_adjust_vm(void *opaque)
 231 {
 232     qemu_mod_timer(icount_vm_timer,
 233                    qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 10);
 234     icount_adjust();
 235 }
 236
 237 static int64_t qemu_icount_round(int64_t count)
 238 {
 239     return (count + (1 << icount_time_shift) - 1) >> icount_time_shift;
 240 }
 241
 242 static void icount_warp_rt(void *opaque)
 243 {
 244     if (vm_clock_warp_start == -1) {
 245         return;
 246     }
 247
 248     if (runstate_is_running()) {
 249         int64_t clock = qemu_get_clock_ns(rt_clock);
 250         int64_t warp_delta = clock - vm_clock_warp_start;
 251         if (use_icount == 1) {
 252             qemu_icount_bias += warp_delta;
 253         } else {
 254             /*
 255              * In adaptive mode, do not let the vm_clock run too
 256              * far ahead of real time.
 257              */
 258             int64_t cur_time = cpu_get_clock();
 259             int64_t cur_icount = qemu_get_clock_ns(vm_clock);
 260             int64_t delta = cur_time - cur_icount;
 261             qemu_icount_bias += MIN(warp_delta, delta);
 262         }
 263         if (qemu_clock_expired(vm_clock)) {
 264             qemu_notify_event();
 265         }
 266     }
 267     vm_clock_warp_start = -1;
 268 }
 269
 270 void qtest_clock_warp(int64_t dest)
 271 {
 272     int64_t clock = qemu_get_clock_ns(vm_clock);
 273     assert(qtest_enabled());
 274     while (clock < dest) {
 275         int64_t deadline = qemu_clock_deadline(vm_clock);
 276         int64_t warp = MIN(dest - clock, deadline);
 277         qemu_icount_bias += warp;
 278         qemu_run_timers(vm_clock);
 279         clock = qemu_get_clock_ns(vm_clock);
 280     }
 281     qemu_notify_event();
 282 }
 283
 284 void qemu_clock_warp(QEMUClock *clock)
 285 {
 286     int64_t deadline;
 287
 288     /*
 289      * There are too many global variables to make the "warp" behavior
 290      * applicable to other clocks.  But a clock argument removes the
 291      * need for if statements all over the place.
 292      */
 293     if (clock != vm_clock || !use_icount) {
 294         return;
 295     }
 296
 297     /*
 298      * If the CPUs have been sleeping, advance the vm_clock timer now.  This
 299      * ensures that the deadline for the timer is computed correctly below.
 300      * This also makes sure that the insn counter is synchronized before the
 301      * CPU starts running, in case the CPU is woken by an event other than
 302      * the earliest vm_clock timer.
 303      */
 304     icount_warp_rt(NULL);
 305     if (!all_cpu_threads_idle() || !qemu_clock_has_timers(vm_clock)) {
 306         qemu_del_timer(icount_warp_timer);
 307         return;
 308     }
 309
 310     if (qtest_enabled()) {
 311         /* When testing, qtest commands advance icount.  */
 312         return;
 313     }
 314
 315     vm_clock_warp_start = qemu_get_clock_ns(rt_clock);
 316     deadline = qemu_clock_deadline(vm_clock);
 317     if (deadline > 0) {
 318         /*
 319          * Ensure the vm_clock proceeds even when the virtual CPU goes to
 320          * sleep.  Otherwise, the CPU might be waiting for a future timer
 321          * interrupt to wake it up, but the interrupt never comes because
 322          * the vCPU isn't running any insns and thus doesn't advance the
 323          * vm_clock.
 324          *
 325          * An extreme solution for this problem would be to never let VCPUs
 326          * sleep in icount mode if there is a pending vm_clock timer; rather
 327          * time could just advance to the next vm_clock event.  Instead, we
 328          * do stop VCPUs and only advance vm_clock after some "real" time,
 329          * (related to the time left until the next event) has passed.  This
 330          * rt_clock timer will do this.  This avoids that the warps are too
 331          * visible externally---for example, you will not be sending network
 332          * packets continuously instead of every 100ms.
 333          */
 334         qemu_mod_timer(icount_warp_timer, vm_clock_warp_start + deadline);
 335     } else {
 336         qemu_notify_event();
 337     }
 338 }
 339
 340 static const VMStateDescription vmstate_timers = {
 341     .name = "timer",
 342     .version_id = 2,
 343     .minimum_version_id = 1,
 344     .minimum_version_id_old = 1,
 345     .fields      = (VMStateField[]) {
 346         VMSTATE_INT64(cpu_ticks_offset, TimersState),
 347         VMSTATE_INT64(dummy, TimersState),
 348         VMSTATE_INT64_V(cpu_clock_offset, TimersState, 2),
 349         VMSTATE_END_OF_LIST()
 350     }
 351 };
 352
 353 void configure_icount(const char *option)
 354 {
 355     vmstate_register(NULL, 0, &vmstate_timers, &timers_state);
 356     if (!option) {
 357         return;
 358     }
 359
 360     icount_warp_timer = qemu_new_timer_ns(rt_clock, icount_warp_rt, NULL);
 361     if (strcmp(option, "auto") != 0) {
 362         icount_time_shift = strtol(option, NULL, 0);
 363         use_icount = 1;
 364         return;
 365     }
 366
 367     use_icount = 2;
 368
 369     /* 125MIPS seems a reasonable initial guess at the guest speed.
 370        It will be corrected fairly quickly anyway.  */
 371     icount_time_shift = 3;
 372
 373     /* Have both realtime and virtual time triggers for speed adjustment.
 374        The realtime trigger catches emulated time passing too slowly,
 375        the virtual time trigger catches emulated time passing too fast.
 376        Realtime triggers occur even when idle, so use them less frequently
 377        than VM triggers.  */
 378     icount_rt_timer = qemu_new_timer_ms(rt_clock, icount_adjust_rt, NULL);
 379     qemu_mod_timer(icount_rt_timer,
 380                    qemu_get_clock_ms(rt_clock) + 1000);
 381     icount_vm_timer = qemu_new_timer_ns(vm_clock, icount_adjust_vm, NULL);
 382     qemu_mod_timer(icount_vm_timer,
 383                    qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 10);
 384 }
 385
 386 /***********************************************************/
 387 void hw_error(const char *fmt, ...)
 388 {
 389     va_list ap;
 390     CPUArchState *env;
 391
 392     va_start(ap, fmt);
 393     fprintf(stderr, "qemu: hardware error: ");
 394     vfprintf(stderr, fmt, ap);
 395     fprintf(stderr, "\n");
 396     for(env = first_cpu; env != NULL; env = env->next_cpu) {
 397         fprintf(stderr, "CPU #%d:\n", env->cpu_index);
 398         cpu_dump_state(env, stderr, fprintf, CPU_DUMP_FPU);
 399     }
 400     va_end(ap);
 401     abort();
 402 }
 403
 404 void cpu_synchronize_all_states(void)
 405 {
 406     CPUArchState *cpu;
 407
 408     for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
 409         cpu_synchronize_state(cpu);
 410     }
 411 }
 412
 413 void cpu_synchronize_all_post_reset(void)
 414 {
 415     CPUArchState *cpu;
 416
 417     for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
 418         cpu_synchronize_post_reset(cpu);
 419     }
 420 }
 421
 422 void cpu_synchronize_all_post_init(void)
 423 {
 424     CPUArchState *cpu;
 425
 426     for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
 427         cpu_synchronize_post_init(cpu);
 428     }
 429 }
 430
 431 int cpu_is_stopped(CPUArchState *env)
 432 {
 433     return !runstate_is_running() || env->stopped;
 434 }
 435
 436 static void do_vm_stop(RunState state)
 437 {
 438     if (runstate_is_running()) {
 439         cpu_disable_ticks();
 440         pause_all_vcpus();
 441         runstate_set(state);
 442         vm_state_notify(0, state);
 443         bdrv_drain_all();
 444         bdrv_flush_all();
 445         monitor_protocol_event(QEVENT_STOP, NULL);
 446     }
 447 }
 448
 449 static int cpu_can_run(CPUArchState *env)
 450 {
 451     if (env->stop) {
 452         return 0;
 453     }
 454     if (env->stopped || !runstate_is_running()) {
 455         return 0;
 456     }
 457     return 1;
 458 }
 459
 460 static void cpu_handle_guest_debug(CPUArchState *env)
 461 {
 462     gdb_set_stop_cpu(env);
 463     qemu_system_debug_request();
 464     env->stopped = 1;
 465 }
 466
 467 static void cpu_signal(int sig)
 468 {
 469     if (cpu_single_env) {
 470         cpu_exit(cpu_single_env);
 471     }
 472     exit_request = 1;
 473 }
 474
 475 #ifdef CONFIG_LINUX
 476 static void sigbus_reraise(void)
 477 {
 478     sigset_t set;
 479     struct sigaction action;
 480
 481     memset(&action, 0, sizeof(action));
 482     action.sa_handler = SIG_DFL;
 483     if (!sigaction(SIGBUS, &action, NULL)) {
 484         raise(SIGBUS);
 485         sigemptyset(&set);
 486         sigaddset(&set, SIGBUS);
 487         sigprocmask(SIG_UNBLOCK, &set, NULL);
 488     }
 489     perror("Failed to re-raise SIGBUS!\n");
 490     abort();
 491 }
 492
 493 static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo,
 494                            void *ctx)
 495 {
 496     if (kvm_on_sigbus(siginfo->ssi_code,
 497                       (void *)(intptr_t)siginfo->ssi_addr)) {
 498         sigbus_reraise();
 499     }
 500 }
 501
 502 static void qemu_init_sigbus(void)
 503 {
 504     struct sigaction action;
 505
 506     memset(&action, 0, sizeof(action));
 507     action.sa_flags = SA_SIGINFO;
 508     action.sa_sigaction = (void (*)(int, siginfo_t*, void*))sigbus_handler;
 509     sigaction(SIGBUS, &action, NULL);
 510
 511     prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, 0, 0);
 512 }
 513
 514 static void qemu_kvm_eat_signals(CPUArchState *env)
 515 {
 516     struct timespec ts = { 0, 0 };
 517     siginfo_t siginfo;
 518     sigset_t waitset;
 519     sigset_t chkset;
 520     int r;
 521
 522     sigemptyset(&waitset);
 523     sigaddset(&waitset, SIG_IPI);
 524     sigaddset(&waitset, SIGBUS);
 525
 526     do {
 527         r = sigtimedwait(&waitset, &siginfo, &ts);
 528         if (r == -1 && !(errno == EAGAIN || errno == EINTR)) {
 529             perror("sigtimedwait");
 530             exit(1);
 531         }
 532
 533         switch (r) {
 534         case SIGBUS:
 535             if (kvm_on_sigbus_vcpu(env, siginfo.si_code, siginfo.si_addr)) {
 536                 sigbus_reraise();
 537             }
 538             break;
 539         default:
 540             break;
 541         }
 542
 543         r = sigpending(&chkset);
 544         if (r == -1) {
 545             perror("sigpending");
 546             exit(1);
 547         }
 548     } while (sigismember(&chkset, SIG_IPI) || sigismember(&chkset, SIGBUS));
 549 }
 550
 551 #else /* !CONFIG_LINUX */
 552
 553 static void qemu_init_sigbus(void)
 554 {
 555 }
 556
 557 static void qemu_kvm_eat_signals(CPUArchState *env)
 558 {
 559 }
 560 #endif /* !CONFIG_LINUX */
 561
 562 #ifndef _WIN32
 563 static void dummy_signal(int sig)
 564 {
 565 }
 566
 567 static void qemu_kvm_init_cpu_signals(CPUArchState *env)
 568 {
 569     int r;
 570     sigset_t set;
 571     struct sigaction sigact;
 572
 573     memset(&sigact, 0, sizeof(sigact));
 574     sigact.sa_handler = dummy_signal;
 575     sigaction(SIG_IPI, &sigact, NULL);
 576
 577     pthread_sigmask(SIG_BLOCK, NULL, &set);
 578     sigdelset(&set, SIG_IPI);
 579     sigdelset(&set, SIGBUS);
 580     r = kvm_set_signal_mask(env, &set);
 581     if (r) {
 582         fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));
 583         exit(1);
 584     }
 585 }
 586
 587 static void qemu_tcg_init_cpu_signals(void)
 588 {
 589     sigset_t set;
 590     struct sigaction sigact;
 591
 592     memset(&sigact, 0, sizeof(sigact));
 593     sigact.sa_handler = cpu_signal;
 594     sigaction(SIG_IPI, &sigact, NULL);
 595
 596     sigemptyset(&set);
 597     sigaddset(&set, SIG_IPI);
 598     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
 599 }
 600
 601 #else /* _WIN32 */
 602 static void qemu_kvm_init_cpu_signals(CPUArchState *env)
 603 {
 604     abort();
 605 }
 606
 607 static void qemu_tcg_init_cpu_signals(void)
 608 {
 609 }
 610 #endif /* _WIN32 */
 611
 612 static QemuMutex qemu_global_mutex;
 613 static QemuCond qemu_io_proceeded_cond;
 614 static bool iothread_requesting_mutex;
 615
 616 static QemuThread io_thread;
 617
 618 static QemuThread *tcg_cpu_thread;
 619 static QemuCond *tcg_halt_cond;
 620
 621 /* cpu creation */
 622 static QemuCond qemu_cpu_cond;
 623 /* system init */
 624 static QemuCond qemu_pause_cond;
 625 static QemuCond qemu_work_cond;
 626
 627 void qemu_init_cpu_loop(void)
 628 {
 629     qemu_init_sigbus();
 630     qemu_cond_init(&qemu_cpu_cond);
 631     qemu_cond_init(&qemu_pause_cond);
 632     qemu_cond_init(&qemu_work_cond);
 633     qemu_cond_init(&qemu_io_proceeded_cond);
 634     qemu_mutex_init(&qemu_global_mutex);
 635
 636     qemu_thread_get_self(&io_thread);
 637 }
 638
 639 void run_on_cpu(CPUArchState *env, void (*func)(void *data), void *data)
 640 {
 641     CPUState *cpu = ENV_GET_CPU(env);
 642     struct qemu_work_item wi;
 643
 644     if (qemu_cpu_is_self(cpu)) {
 645         func(data);
 646         return;
 647     }
 648
 649     wi.func = func;
 650     wi.data = data;
 651     if (!env->queued_work_first) {
 652         env->queued_work_first = &wi;
 653     } else {
 654         env->queued_work_last->next = &wi;
 655     }
 656     env->queued_work_last = &wi;
 657     wi.next = NULL;
 658     wi.done = false;
 659
 660     qemu_cpu_kick(env);
 661     while (!wi.done) {
 662         CPUArchState *self_env = cpu_single_env;
 663
 664         qemu_cond_wait(&qemu_work_cond, &qemu_global_mutex);
 665         cpu_single_env = self_env;
 666     }
 667 }
 668
 669 static void flush_queued_work(CPUArchState *env)
 670 {
 671     struct qemu_work_item *wi;
 672
 673     if (!env->queued_work_first) {
 674         return;
 675     }
 676
 677     while ((wi = env->queued_work_first)) {
 678         env->queued_work_first = wi->next;
 679         wi->func(wi->data);
 680         wi->done = true;
 681     }
 682     env->queued_work_last = NULL;
 683     qemu_cond_broadcast(&qemu_work_cond);
 684 }
 685
 686 static void qemu_wait_io_event_common(CPUArchState *env)
 687 {
 688     CPUState *cpu = ENV_GET_CPU(env);
 689
 690     if (env->stop) {
 691         env->stop = 0;
 692         env->stopped = 1;
 693         qemu_cond_signal(&qemu_pause_cond);
 694     }
 695     flush_queued_work(env);
 696     cpu->thread_kicked = false;
 697 }
 698
 699 static void qemu_tcg_wait_io_event(void)
 700 {
 701     CPUArchState *env;
 702
 703     while (all_cpu_threads_idle()) {
 704        /* Start accounting real time to the virtual clock if the CPUs
 705           are idle.  */
 706         qemu_clock_warp(vm_clock);
 707         qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
 708     }
 709
 710     while (iothread_requesting_mutex) {
 711         qemu_cond_wait(&qemu_io_proceeded_cond, &qemu_global_mutex);
 712     }
 713
 714     for (env = first_cpu; env != NULL; env = env->next_cpu) {
 715         qemu_wait_io_event_common(env);
 716     }
 717 }
 718
 719 static void qemu_kvm_wait_io_event(CPUArchState *env)
 720 {
 721     while (cpu_thread_is_idle(env)) {
 722         qemu_cond_wait(env->halt_cond, &qemu_global_mutex);
 723     }
 724
 725     qemu_kvm_eat_signals(env);
 726     qemu_wait_io_event_common(env);
 727 }
 728
 729 static void *qemu_kvm_cpu_thread_fn(void *arg)
 730 {
 731     CPUArchState *env = arg;
 732     CPUState *cpu = ENV_GET_CPU(env);
 733     int r;
 734
 735     qemu_mutex_lock(&qemu_global_mutex);
 736     qemu_thread_get_self(cpu->thread);
 737     env->thread_id = qemu_get_thread_id();
 738     cpu_single_env = env;
 739
 740     r = kvm_init_vcpu(env);
 741     if (r < 0) {
 742         fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r));
 743         exit(1);
 744     }
 745
 746     qemu_kvm_init_cpu_signals(env);
 747
 748     /* signal CPU creation */
 749     env->created = 1;
 750     qemu_cond_signal(&qemu_cpu_cond);
 751
 752     while (1) {
 753         if (cpu_can_run(env)) {
 754             r = kvm_cpu_exec(env);
 755             if (r == EXCP_DEBUG) {
 756                 cpu_handle_guest_debug(env);
 757             }
 758         }
 759         qemu_kvm_wait_io_event(env);
 760     }
 761
 762     return NULL;
 763 }
 764
 765 static void *qemu_dummy_cpu_thread_fn(void *arg)
 766 {
 767 #ifdef _WIN32
 768     fprintf(stderr, "qtest is not supported under Windows\n");
 769     exit(1);
 770 #else
 771     CPUArchState *env = arg;
 772     CPUState *cpu = ENV_GET_CPU(env);
 773     sigset_t waitset;
 774     int r;
 775
 776     qemu_mutex_lock_iothread();
 777     qemu_thread_get_self(cpu->thread);
 778     env->thread_id = qemu_get_thread_id();
 779
 780     sigemptyset(&waitset);
 781     sigaddset(&waitset, SIG_IPI);
 782
 783     /* signal CPU creation */
 784     env->created = 1;
 785     qemu_cond_signal(&qemu_cpu_cond);
 786
 787     cpu_single_env = env;
 788     while (1) {
 789         cpu_single_env = NULL;
 790         qemu_mutex_unlock_iothread();
 791         do {
 792             int sig;
 793             r = sigwait(&waitset, &sig);
 794         } while (r == -1 && (errno == EAGAIN || errno == EINTR));
 795         if (r == -1) {
 796             perror("sigwait");
 797             exit(1);
 798         }
 799         qemu_mutex_lock_iothread();
 800         cpu_single_env = env;
 801         qemu_wait_io_event_common(env);
 802     }
 803
 804     return NULL;
 805 #endif
 806 }
 807
 808 static void tcg_exec_all(void);
 809
 810 static void *qemu_tcg_cpu_thread_fn(void *arg)
 811 {
 812     CPUArchState *env = arg;
 813     CPUState *cpu = ENV_GET_CPU(env);
 814
 815     qemu_tcg_init_cpu_signals();
 816     qemu_thread_get_self(cpu->thread);
 817
 818     /* signal CPU creation */
 819     qemu_mutex_lock(&qemu_global_mutex);
 820     for (env = first_cpu; env != NULL; env = env->next_cpu) {
 821         env->thread_id = qemu_get_thread_id();
 822         env->created = 1;
 823     }
 824     qemu_cond_signal(&qemu_cpu_cond);
 825
 826     /* wait for initial kick-off after machine start */
 827     while (first_cpu->stopped) {
 828         qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
 829
 830         /* process any pending work */
 831         for (env = first_cpu; env != NULL; env = env->next_cpu) {
 832             qemu_wait_io_event_common(env);
 833         }
 834     }
 835
 836     while (1) {
 837         tcg_exec_all();
 838         if (use_icount && qemu_clock_deadline(vm_clock) <= 0) {
 839             qemu_notify_event();
 840         }
 841         qemu_tcg_wait_io_event();
 842     }
 843
 844     return NULL;
 845 }
 846
 847 static void qemu_cpu_kick_thread(CPUState *cpu)
 848 {
 849 #ifndef _WIN32
 850     int err;
 851
 852     err = pthread_kill(cpu->thread->thread, SIG_IPI);
 853     if (err) {
 854         fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
 855         exit(1);
 856     }
 857 #else /* _WIN32 */
 858     if (!qemu_cpu_is_self(cpu)) {
 859         SuspendThread(cpu->hThread);
 860         cpu_signal(0);
 861         ResumeThread(cpu->hThread);
 862     }
 863 #endif
 864 }
 865
 866 void qemu_cpu_kick(void *_env)
 867 {
 868     CPUArchState *env = _env;
 869     CPUState *cpu = ENV_GET_CPU(env);
 870
 871     qemu_cond_broadcast(env->halt_cond);
 872     if (!tcg_enabled() && !cpu->thread_kicked) {
 873         qemu_cpu_kick_thread(cpu);
 874         cpu->thread_kicked = true;
 875     }
 876 }
 877
 878 void qemu_cpu_kick_self(void)
 879 {
 880 #ifndef _WIN32
 881     assert(cpu_single_env);
 882     CPUState *cpu_single_cpu = ENV_GET_CPU(cpu_single_env);
 883
 884     if (!cpu_single_cpu->thread_kicked) {
 885         qemu_cpu_kick_thread(cpu_single_cpu);
 886         cpu_single_cpu->thread_kicked = true;
 887     }
 888 #else
 889     abort();
 890 #endif
 891 }
 892
 893 bool qemu_cpu_is_self(CPUState *cpu)
 894 {
 895     return qemu_thread_is_self(cpu->thread);
 896 }
 897
 898 static bool qemu_in_vcpu_thread(void)
 899 {
 900     return cpu_single_env && qemu_cpu_is_self(ENV_GET_CPU(cpu_single_env));
 901 }
 902
 903 void qemu_mutex_lock_iothread(void)
 904 {
 905     if (!tcg_enabled()) {
 906         qemu_mutex_lock(&qemu_global_mutex);
 907     } else {
 908         iothread_requesting_mutex = true;
 909         if (qemu_mutex_trylock(&qemu_global_mutex)) {
 910             qemu_cpu_kick_thread(ENV_GET_CPU(first_cpu));
 911             qemu_mutex_lock(&qemu_global_mutex);
 912         }
 913         iothread_requesting_mutex = false;
 914         qemu_cond_broadcast(&qemu_io_proceeded_cond);
 915     }
 916 }
 917
 918 void qemu_mutex_unlock_iothread(void)
 919 {
 920     qemu_mutex_unlock(&qemu_global_mutex);
 921 }
 922
 923 static int all_vcpus_paused(void)
 924 {
 925     CPUArchState *penv = first_cpu;
 926
 927     while (penv) {
 928         if (!penv->stopped) {
 929             return 0;
 930         }
 931         penv = penv->next_cpu;
 932     }
 933
 934     return 1;
 935 }
 936
 937 void pause_all_vcpus(void)
 938 {
 939     CPUArchState *penv = first_cpu;
 940
 941     qemu_clock_enable(vm_clock, false);
 942     while (penv) {
 943         penv->stop = 1;
 944         qemu_cpu_kick(penv);
 945         penv = penv->next_cpu;
 946     }
 947
 948     if (qemu_in_vcpu_thread()) {
 949         cpu_stop_current();
 950         if (!kvm_enabled()) {
 951             while (penv) {
 952                 penv->stop = 0;
 953                 penv->stopped = 1;
 954                 penv = penv->next_cpu;
 955             }
 956             return;
 957         }
 958     }
 959
 960     while (!all_vcpus_paused()) {
 961         qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
 962         penv = first_cpu;
 963         while (penv) {
 964             qemu_cpu_kick(penv);
 965             penv = penv->next_cpu;
 966         }
 967     }
 968 }
 969
 970 void resume_all_vcpus(void)
 971 {
 972     CPUArchState *penv = first_cpu;
 973
 974     qemu_clock_enable(vm_clock, true);
 975     while (penv) {
 976         penv->stop = 0;
 977         penv->stopped = 0;
 978         qemu_cpu_kick(penv);
 979         penv = penv->next_cpu;
 980     }
 981 }
 982
 983 static void qemu_tcg_init_vcpu(void *_env)
 984 {
 985     CPUArchState *env = _env;
 986     CPUState *cpu = ENV_GET_CPU(env);
 987
 988     /* share a single thread for all cpus with TCG */
 989     if (!tcg_cpu_thread) {
 990         cpu->thread = g_malloc0(sizeof(QemuThread));
 991         env->halt_cond = g_malloc0(sizeof(QemuCond));
 992         qemu_cond_init(env->halt_cond);
 993         tcg_halt_cond = env->halt_cond;
 994         qemu_thread_create(cpu->thread, qemu_tcg_cpu_thread_fn, env,
 995                            QEMU_THREAD_JOINABLE);
 996 #ifdef _WIN32
 997         cpu->hThread = qemu_thread_get_handle(cpu->thread);
 998 #endif
 999         while (env->created == 0) {
1000             qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1001         }
1002         tcg_cpu_thread = cpu->thread;
1003     } else {
1004         cpu->thread = tcg_cpu_thread;
1005         env->halt_cond = tcg_halt_cond;
1006     }
1007 }
1008
1009 static void qemu_kvm_start_vcpu(CPUArchState *env)
1010 {
1011     CPUState *cpu = ENV_GET_CPU(env);
1012
1013     cpu->thread = g_malloc0(sizeof(QemuThread));
1014     env->halt_cond = g_malloc0(sizeof(QemuCond));
1015     qemu_cond_init(env->halt_cond);
1016     qemu_thread_create(cpu->thread, qemu_kvm_cpu_thread_fn, env,
1017                        QEMU_THREAD_JOINABLE);
1018     while (env->created == 0) {
1019         qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1020     }
1021 }
1022
1023 static void qemu_dummy_start_vcpu(CPUArchState *env)
1024 {
1025     CPUState *cpu = ENV_GET_CPU(env);
1026
1027     cpu->thread = g_malloc0(sizeof(QemuThread));
1028     env->halt_cond = g_malloc0(sizeof(QemuCond));
1029     qemu_cond_init(env->halt_cond);
1030     qemu_thread_create(cpu->thread, qemu_dummy_cpu_thread_fn, env,
1031                        QEMU_THREAD_JOINABLE);
1032     while (env->created == 0) {
1033         qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1034     }
1035 }
1036
1037 void qemu_init_vcpu(void *_env)
1038 {
1039     CPUArchState *env = _env;
1040
1041     env->nr_cores = smp_cores;
1042     env->nr_threads = smp_threads;
1043     env->stopped = 1;
1044     if (kvm_enabled()) {
1045         qemu_kvm_start_vcpu(env);
1046     } else if (tcg_enabled()) {
1047         qemu_tcg_init_vcpu(env);
1048     } else {
1049         qemu_dummy_start_vcpu(env);
1050     }
1051 }
1052
1053 void cpu_stop_current(void)
1054 {
1055     if (cpu_single_env) {
1056         cpu_single_env->stop = 0;
1057         cpu_single_env->stopped = 1;
1058         cpu_exit(cpu_single_env);
1059         qemu_cond_signal(&qemu_pause_cond);
1060     }
1061 }
1062
1063 void vm_stop(RunState state)
1064 {
1065     if (qemu_in_vcpu_thread()) {
1066         qemu_system_vmstop_request(state);
1067         /*
1068          * FIXME: should not return to device code in case
1069          * vm_stop() has been requested.
1070          */
1071         cpu_stop_current();
1072         return;
1073     }
1074     do_vm_stop(state);
1075 }
1076
1077 /* does a state transition even if the VM is already stopped,
1078    current state is forgotten forever */
1079 void vm_stop_force_state(RunState state)
1080 {
1081     if (runstate_is_running()) {
1082         vm_stop(state);
1083     } else {
1084         runstate_set(state);
1085     }
1086 }
1087
1088 static int tcg_cpu_exec(CPUArchState *env)
1089 {
1090     int ret;
1091 #ifdef CONFIG_PROFILER
1092     int64_t ti;
1093 #endif
1094
1095 #ifdef CONFIG_PROFILER
1096     ti = profile_getclock();
1097 #endif
1098     if (use_icount) {
1099         int64_t count;
1100         int decr;
1101         qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
1102         env->icount_decr.u16.low = 0;
1103         env->icount_extra = 0;
1104         count = qemu_icount_round(qemu_clock_deadline(vm_clock));
1105         qemu_icount += count;
1106         decr = (count > 0xffff) ? 0xffff : count;
1107         count -= decr;
1108         env->icount_decr.u16.low = decr;
1109         env->icount_extra = count;
1110     }
1111     ret = cpu_exec(env);
1112 #ifdef CONFIG_PROFILER
1113     qemu_time += profile_getclock() - ti;
1114 #endif
1115     if (use_icount) {
1116         /* Fold pending instructions back into the
1117            instruction counter, and clear the interrupt flag.  */
1118         qemu_icount -= (env->icount_decr.u16.low
1119                         + env->icount_extra);
1120         env->icount_decr.u32 = 0;
1121         env->icount_extra = 0;
1122     }
1123     return ret;
1124 }
1125
1126 static void tcg_exec_all(void)
1127 {
1128     int r;
1129
1130     /* Account partial waits to the vm_clock.  */
1131     qemu_clock_warp(vm_clock);
1132
1133     if (next_cpu == NULL) {
1134         next_cpu = first_cpu;
1135     }
1136     for (; next_cpu != NULL && !exit_request; next_cpu = next_cpu->next_cpu) {
1137         CPUArchState *env = next_cpu;
1138
1139         qemu_clock_enable(vm_clock,
1140                           (env->singlestep_enabled & SSTEP_NOTIMER) == 0);
1141
1142         if (cpu_can_run(env)) {
1143             r = tcg_cpu_exec(env);
1144             if (r == EXCP_DEBUG) {
1145                 cpu_handle_guest_debug(env);
1146                 break;
1147             }
1148         } else if (env->stop || env->stopped) {
1149             break;
1150         }
1151     }
1152     exit_request = 0;
1153 }
1154
1155 void set_numa_modes(void)
1156 {
1157     CPUArchState *env;
1158     int i;
1159
1160     for (env = first_cpu; env != NULL; env = env->next_cpu) {
1161         for (i = 0; i < nb_numa_nodes; i++) {
1162             if (test_bit(env->cpu_index, node_cpumask[i])) {
1163                 env->numa_node = i;
1164             }
1165         }
1166     }
1167 }
1168
1169 void set_cpu_log(const char *optarg)
1170 {
1171     int mask;
1172     const CPULogItem *item;
1173
1174     mask = cpu_str_to_log_mask(optarg);
1175     if (!mask) {
1176         printf("Log items (comma separated):\n");
1177         for (item = cpu_log_items; item->mask != 0; item++) {
1178             printf("%-10s %s\n", item->name, item->help);
1179         }
1180         exit(1);
1181     }
1182     cpu_set_log(mask);
1183 }
1184
1185 void set_cpu_log_filename(const char *optarg)
1186 {
1187     cpu_set_log_filename(optarg);
1188 }
1189
1190 void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
1191 {
1192     /* XXX: implement xxx_cpu_list for targets that still miss it */
1193 #if defined(cpu_list)
1194     cpu_list(f, cpu_fprintf);
1195 #endif
1196 }
1197
1198 CpuInfoList *qmp_query_cpus(Error **errp)
1199 {
1200     CpuInfoList *head = NULL, *cur_item = NULL;
1201     CPUArchState *env;
1202
1203     for(env = first_cpu; env != NULL; env = env->next_cpu) {
1204         CpuInfoList *info;
1205
1206         cpu_synchronize_state(env);
1207
1208         info = g_malloc0(sizeof(*info));
1209         info->value = g_malloc0(sizeof(*info->value));
1210         info->value->CPU = env->cpu_index;
1211         info->value->current = (env == first_cpu);
1212         info->value->halted = env->halted;
1213         info->value->thread_id = env->thread_id;
1214 #if defined(TARGET_I386)
1215         info->value->has_pc = true;
1216         info->value->pc = env->eip + env->segs[R_CS].base;
1217 #elif defined(TARGET_PPC)
1218         info->value->has_nip = true;
1219         info->value->nip = env->nip;
1220 #elif defined(TARGET_SPARC)
1221         info->value->has_pc = true;
1222         info->value->pc = env->pc;
1223         info->value->has_npc = true;
1224         info->value->npc = env->npc;
1225 #elif defined(TARGET_MIPS)
1226         info->value->has_PC = true;
1227         info->value->PC = env->active_tc.PC;
1228 #endif
1229
1230         /* XXX: waiting for the qapi to support GSList */
1231         if (!cur_item) {
1232             head = cur_item = info;
1233         } else {
1234             cur_item->next = info;
1235             cur_item = info;
1236         }
1237     }
1238
1239     return head;
1240 }
1241
1242 void qmp_memsave(int64_t addr, int64_t size, const char *filename,
1243                  bool has_cpu, int64_t cpu_index, Error **errp)
1244 {
1245     FILE *f;
1246     uint32_t l;
1247     CPUArchState *env;
1248     uint8_t buf[1024];
1249
1250     if (!has_cpu) {
1251         cpu_index = 0;
1252     }
1253
1254     for (env = first_cpu; env; env = env->next_cpu) {
1255         if (cpu_index == env->cpu_index) {
1256             break;
1257         }
1258     }
1259
1260     if (env == NULL) {
1261         error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
1262                   "a CPU number");
1263         return;
1264     }
1265
1266     f = fopen(filename, "wb");
1267     if (!f) {
1268         error_set(errp, QERR_OPEN_FILE_FAILED, filename);
1269         return;
1270     }
1271
1272     while (size != 0) {
1273         l = sizeof(buf);
1274         if (l > size)
1275             l = size;
1276         cpu_memory_rw_debug(env, addr, buf, l, 0);
1277         if (fwrite(buf, 1, l, f) != l) {
1278             error_set(errp, QERR_IO_ERROR);
1279             goto exit;
1280         }
1281         addr += l;
1282         size -= l;
1283     }
1284
1285 exit:
1286     fclose(f);
1287 }
1288
1289 void qmp_pmemsave(int64_t addr, int64_t size, const char *filename,
1290                   Error **errp)
1291 {
1292     FILE *f;
1293     uint32_t l;
1294     uint8_t buf[1024];
1295
1296     f = fopen(filename, "wb");
1297     if (!f) {
1298         error_set(errp, QERR_OPEN_FILE_FAILED, filename);
1299         return;
1300     }
1301
1302     while (size != 0) {
1303         l = sizeof(buf);
1304         if (l > size)
1305             l = size;
1306         cpu_physical_memory_rw(addr, buf, l, 0);
1307         if (fwrite(buf, 1, l, f) != l) {
1308             error_set(errp, QERR_IO_ERROR);
1309             goto exit;
1310         }
1311         addr += l;
1312         size -= l;
1313     }
1314
1315 exit:
1316     fclose(f);
1317 }
1318
1319 void qmp_inject_nmi(Error **errp)
1320 {
1321 #if defined(TARGET_I386)
1322     CPUArchState *env;
1323
1324     for (env = first_cpu; env != NULL; env = env->next_cpu) {
1325         if (!env->apic_state) {
1326             cpu_interrupt(env, CPU_INTERRUPT_NMI);
1327         } else {
1328             apic_deliver_nmi(env->apic_state);
1329         }
1330     }
1331 #else
1332     error_set(errp, QERR_UNSUPPORTED);
1333 #endif
1334 }