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 "qemu/osdep.h"
  27 #include "qemu-common.h"
  28 #include "cpu.h"
  29 #include "monitor/monitor.h"
  30 #include "qapi/qmp/qerror.h"
  31 #include "qemu/error-report.h"
  32 #include "sysemu/sysemu.h"
  33 #include "sysemu/block-backend.h"
  34 #include "exec/gdbstub.h"
  35 #include "sysemu/dma.h"
  36 #include "sysemu/kvm.h"
  37 #include "qmp-commands.h"
  38 #include "exec/exec-all.h"
  39
  40 #include "qemu/thread.h"
  41 #include "sysemu/cpus.h"
  42 #include "sysemu/qtest.h"
  43 #include "qemu/main-loop.h"
  44 #include "qemu/bitmap.h"
  45 #include "qemu/seqlock.h"
  46 #include "qapi-event.h"
  47 #include "hw/nmi.h"
  48 #include "sysemu/replay.h"
  49
  50 #ifndef _WIN32
  51 #include "qemu/compatfd.h"
  52 #endif
  53
  54 #ifdef CONFIG_LINUX
  55
  56 #include <sys/prctl.h>
  57
  58 #ifndef PR_MCE_KILL
  59 #define PR_MCE_KILL 33
  60 #endif
  61
  62 #ifndef PR_MCE_KILL_SET
  63 #define PR_MCE_KILL_SET 1
  64 #endif
  65
  66 #ifndef PR_MCE_KILL_EARLY
  67 #define PR_MCE_KILL_EARLY 1
  68 #endif
  69
  70 #endif /* CONFIG_LINUX */
  71
  72 static CPUState *next_cpu;
  73 int64_t max_delay;
  74 int64_t max_advance;
  75
  76 /* vcpu throttling controls */
  77 static QEMUTimer *throttle_timer;
  78 static unsigned int throttle_percentage;
  79
  80 #define CPU_THROTTLE_PCT_MIN 1
  81 #define CPU_THROTTLE_PCT_MAX 99
  82 #define CPU_THROTTLE_TIMESLICE_NS 10000000
  83
  84 bool cpu_is_stopped(CPUState *cpu)
  85 {
  86     return cpu->stopped || !runstate_is_running();
  87 }
  88
  89 static bool cpu_thread_is_idle(CPUState *cpu)
  90 {
  91     if (cpu->stop || cpu->queued_work_first) {
  92         return false;
  93     }
  94     if (cpu_is_stopped(cpu)) {
  95         return true;
  96     }
  97     if (!cpu->halted || cpu_has_work(cpu) ||
  98         kvm_halt_in_kernel()) {
  99         return false;
 100     }
 101     return true;
 102 }
 103
 104 static bool all_cpu_threads_idle(void)
 105 {
 106     CPUState *cpu;
 107
 108     CPU_FOREACH(cpu) {
 109         if (!cpu_thread_is_idle(cpu)) {
 110             return false;
 111         }
 112     }
 113     return true;
 114 }
 115
 116 /***********************************************************/
 117 /* guest cycle counter */
 118
 119 /* Protected by TimersState seqlock */
 120
 121 static bool icount_sleep = true;
 122 static int64_t vm_clock_warp_start = -1;
 123 /* Conversion factor from emulated instructions to virtual clock ticks.  */
 124 static int icount_time_shift;
 125 /* Arbitrarily pick 1MIPS as the minimum allowable speed.  */
 126 #define MAX_ICOUNT_SHIFT 10
 127
 128 static QEMUTimer *icount_rt_timer;
 129 static QEMUTimer *icount_vm_timer;
 130 static QEMUTimer *icount_warp_timer;
 131
 132 typedef struct TimersState {
 133     /* Protected by BQL.  */
 134     int64_t cpu_ticks_prev;
 135     int64_t cpu_ticks_offset;
 136
 137     /* cpu_clock_offset can be read out of BQL, so protect it with
 138      * this lock.
 139      */
 140     QemuSeqLock vm_clock_seqlock;
 141     int64_t cpu_clock_offset;
 142     int32_t cpu_ticks_enabled;
 143     int64_t dummy;
 144
 145     /* Compensate for varying guest execution speed.  */
 146     int64_t qemu_icount_bias;
 147     /* Only written by TCG thread */
 148     int64_t qemu_icount;
 149 } TimersState;
 150
 151 static TimersState timers_state;
 152
 153 int64_t cpu_get_icount_raw(void)
 154 {
 155     int64_t icount;
 156     CPUState *cpu = current_cpu;
 157
 158     icount = timers_state.qemu_icount;
 159     if (cpu) {
 160         if (!cpu->can_do_io) {
 161             fprintf(stderr, "Bad icount read\n");
 162             exit(1);
 163         }
 164         icount -= (cpu->icount_decr.u16.low + cpu->icount_extra);
 165     }
 166     return icount;
 167 }
 168
 169 /* Return the virtual CPU time, based on the instruction counter.  */
 170 static int64_t cpu_get_icount_locked(void)
 171 {
 172     int64_t icount = cpu_get_icount_raw();
 173     return timers_state.qemu_icount_bias + cpu_icount_to_ns(icount);
 174 }
 175
 176 int64_t cpu_get_icount(void)
 177 {
 178     int64_t icount;
 179     unsigned start;
 180
 181     do {
 182         start = seqlock_read_begin(&timers_state.vm_clock_seqlock);
 183         icount = cpu_get_icount_locked();
 184     } while (seqlock_read_retry(&timers_state.vm_clock_seqlock, start));
 185
 186     return icount;
 187 }
 188
 189 int64_t cpu_icount_to_ns(int64_t icount)
 190 {
 191     return icount << icount_time_shift;
 192 }
 193
 194 /* return the time elapsed in VM between vm_start and vm_stop.  Unless
 195  * icount is active, cpu_get_ticks() uses units of the host CPU cycle
 196  * counter.
 197  *
 198  * Caller must hold the BQL
 199  */
 200 int64_t cpu_get_ticks(void)
 201 {
 202     int64_t ticks;
 203
 204     if (use_icount) {
 205         return cpu_get_icount();
 206     }
 207
 208     ticks = timers_state.cpu_ticks_offset;
 209     if (timers_state.cpu_ticks_enabled) {
 210         ticks += cpu_get_host_ticks();
 211     }
 212
 213     if (timers_state.cpu_ticks_prev > ticks) {
 214         /* Note: non increasing ticks may happen if the host uses
 215            software suspend */
 216         timers_state.cpu_ticks_offset += timers_state.cpu_ticks_prev - ticks;
 217         ticks = timers_state.cpu_ticks_prev;
 218     }
 219
 220     timers_state.cpu_ticks_prev = ticks;
 221     return ticks;
 222 }
 223
 224 static int64_t cpu_get_clock_locked(void)
 225 {
 226     int64_t time;
 227
 228     time = timers_state.cpu_clock_offset;
 229     if (timers_state.cpu_ticks_enabled) {
 230         time += get_clock();
 231     }
 232
 233     return time;
 234 }
 235
 236 /* Return the monotonic time elapsed in VM, i.e.,
 237  * the time between vm_start and vm_stop
 238  */
 239 int64_t cpu_get_clock(void)
 240 {
 241     int64_t ti;
 242     unsigned start;
 243
 244     do {
 245         start = seqlock_read_begin(&timers_state.vm_clock_seqlock);
 246         ti = cpu_get_clock_locked();
 247     } while (seqlock_read_retry(&timers_state.vm_clock_seqlock, start));
 248
 249     return ti;
 250 }
 251
 252 /* enable cpu_get_ticks()
 253  * Caller must hold BQL which serves as mutex for vm_clock_seqlock.
 254  */
 255 void cpu_enable_ticks(void)
 256 {
 257     /* Here, the really thing protected by seqlock is cpu_clock_offset. */
 258     seqlock_write_begin(&timers_state.vm_clock_seqlock);
 259     if (!timers_state.cpu_ticks_enabled) {
 260         timers_state.cpu_ticks_offset -= cpu_get_host_ticks();
 261         timers_state.cpu_clock_offset -= get_clock();
 262         timers_state.cpu_ticks_enabled = 1;
 263     }
 264     seqlock_write_end(&timers_state.vm_clock_seqlock);
 265 }
 266
 267 /* disable cpu_get_ticks() : the clock is stopped. You must not call
 268  * cpu_get_ticks() after that.
 269  * Caller must hold BQL which serves as mutex for vm_clock_seqlock.
 270  */
 271 void cpu_disable_ticks(void)
 272 {
 273     /* Here, the really thing protected by seqlock is cpu_clock_offset. */
 274     seqlock_write_begin(&timers_state.vm_clock_seqlock);
 275     if (timers_state.cpu_ticks_enabled) {
 276         timers_state.cpu_ticks_offset += cpu_get_host_ticks();
 277         timers_state.cpu_clock_offset = cpu_get_clock_locked();
 278         timers_state.cpu_ticks_enabled = 0;
 279     }
 280     seqlock_write_end(&timers_state.vm_clock_seqlock);
 281 }
 282
 283 /* Correlation between real and virtual time is always going to be
 284    fairly approximate, so ignore small variation.
 285    When the guest is idle real and virtual time will be aligned in
 286    the IO wait loop.  */
 287 #define ICOUNT_WOBBLE (NANOSECONDS_PER_SECOND / 10)
 288
 289 static void icount_adjust(void)
 290 {
 291     int64_t cur_time;
 292     int64_t cur_icount;
 293     int64_t delta;
 294
 295     /* Protected by TimersState mutex.  */
 296     static int64_t last_delta;
 297
 298     /* If the VM is not running, then do nothing.  */
 299     if (!runstate_is_running()) {
 300         return;
 301     }
 302
 303     seqlock_write_begin(&timers_state.vm_clock_seqlock);
 304     cur_time = cpu_get_clock_locked();
 305     cur_icount = cpu_get_icount_locked();
 306
 307     delta = cur_icount - cur_time;
 308     /* FIXME: This is a very crude algorithm, somewhat prone to oscillation.  */
 309     if (delta > 0
 310         && last_delta + ICOUNT_WOBBLE < delta * 2
 311         && icount_time_shift > 0) {
 312         /* The guest is getting too far ahead.  Slow time down.  */
 313         icount_time_shift--;
 314     }
 315     if (delta < 0
 316         && last_delta - ICOUNT_WOBBLE > delta * 2
 317         && icount_time_shift < MAX_ICOUNT_SHIFT) {
 318         /* The guest is getting too far behind.  Speed time up.  */
 319         icount_time_shift++;
 320     }
 321     last_delta = delta;
 322     timers_state.qemu_icount_bias = cur_icount
 323                               - (timers_state.qemu_icount << icount_time_shift);
 324     seqlock_write_end(&timers_state.vm_clock_seqlock);
 325 }
 326
 327 static void icount_adjust_rt(void *opaque)
 328 {
 329     timer_mod(icount_rt_timer,
 330               qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT) + 1000);
 331     icount_adjust();
 332 }
 333
 334 static void icount_adjust_vm(void *opaque)
 335 {
 336     timer_mod(icount_vm_timer,
 337                    qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
 338                    NANOSECONDS_PER_SECOND / 10);
 339     icount_adjust();
 340 }
 341
 342 static int64_t qemu_icount_round(int64_t count)
 343 {
 344     return (count + (1 << icount_time_shift) - 1) >> icount_time_shift;
 345 }
 346
 347 static void icount_warp_rt(void)
 348 {
 349     unsigned seq;
 350     int64_t warp_start;
 351
 352     /* The icount_warp_timer is rescheduled soon after vm_clock_warp_start
 353      * changes from -1 to another value, so the race here is okay.
 354      */
 355     do {
 356         seq = seqlock_read_begin(&timers_state.vm_clock_seqlock);
 357         warp_start = vm_clock_warp_start;
 358     } while (seqlock_read_retry(&timers_state.vm_clock_seqlock, seq));
 359
 360     if (warp_start == -1) {
 361         return;
 362     }
 363
 364     seqlock_write_begin(&timers_state.vm_clock_seqlock);
 365     if (runstate_is_running()) {
 366         int64_t clock = REPLAY_CLOCK(REPLAY_CLOCK_VIRTUAL_RT,
 367                                      cpu_get_clock_locked());
 368         int64_t warp_delta;
 369
 370         warp_delta = clock - vm_clock_warp_start;
 371         if (use_icount == 2) {
 372             /*
 373              * In adaptive mode, do not let QEMU_CLOCK_VIRTUAL run too
 374              * far ahead of real time.
 375              */
 376             int64_t cur_icount = cpu_get_icount_locked();
 377             int64_t delta = clock - cur_icount;
 378             warp_delta = MIN(warp_delta, delta);
 379         }
 380         timers_state.qemu_icount_bias += warp_delta;
 381     }
 382     vm_clock_warp_start = -1;
 383     seqlock_write_end(&timers_state.vm_clock_seqlock);
 384
 385     if (qemu_clock_expired(QEMU_CLOCK_VIRTUAL)) {
 386         qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
 387     }
 388 }
 389
 390 static void icount_timer_cb(void *opaque)
 391 {
 392     /* No need for a checkpoint because the timer already synchronizes
 393      * with CHECKPOINT_CLOCK_VIRTUAL_RT.
 394      */
 395     icount_warp_rt();
 396 }
 397
 398 void qtest_clock_warp(int64_t dest)
 399 {
 400     int64_t clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
 401     AioContext *aio_context;
 402     assert(qtest_enabled());
 403     aio_context = qemu_get_aio_context();
 404     while (clock < dest) {
 405         int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
 406         int64_t warp = qemu_soonest_timeout(dest - clock, deadline);
 407
 408         seqlock_write_begin(&timers_state.vm_clock_seqlock);
 409         timers_state.qemu_icount_bias += warp;
 410         seqlock_write_end(&timers_state.vm_clock_seqlock);
 411
 412         qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
 413         timerlist_run_timers(aio_context->tlg.tl[QEMU_CLOCK_VIRTUAL]);
 414         clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
 415     }
 416     qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
 417 }
 418
 419 void qemu_start_warp_timer(void)
 420 {
 421     int64_t clock;
 422     int64_t deadline;
 423
 424     if (!use_icount) {
 425         return;
 426     }
 427
 428     /* Nothing to do if the VM is stopped: QEMU_CLOCK_VIRTUAL timers
 429      * do not fire, so computing the deadline does not make sense.
 430      */
 431     if (!runstate_is_running()) {
 432         return;
 433     }
 434
 435     /* warp clock deterministically in record/replay mode */
 436     if (!replay_checkpoint(CHECKPOINT_CLOCK_WARP_START)) {
 437         return;
 438     }
 439
 440     if (!all_cpu_threads_idle()) {
 441         return;
 442     }
 443
 444     if (qtest_enabled()) {
 445         /* When testing, qtest commands advance icount.  */
 446         return;
 447     }
 448
 449     /* We want to use the earliest deadline from ALL vm_clocks */
 450     clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT);
 451     deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
 452     if (deadline < 0) {
 453         static bool notified;
 454         if (!icount_sleep && !notified) {
 455             error_report("WARNING: icount sleep disabled and no active timers");
 456             notified = true;
 457         }
 458         return;
 459     }
 460
 461     if (deadline > 0) {
 462         /*
 463          * Ensure QEMU_CLOCK_VIRTUAL proceeds even when the virtual CPU goes to
 464          * sleep.  Otherwise, the CPU might be waiting for a future timer
 465          * interrupt to wake it up, but the interrupt never comes because
 466          * the vCPU isn't running any insns and thus doesn't advance the
 467          * QEMU_CLOCK_VIRTUAL.
 468          */
 469         if (!icount_sleep) {
 470             /*
 471              * We never let VCPUs sleep in no sleep icount mode.
 472              * If there is a pending QEMU_CLOCK_VIRTUAL timer we just advance
 473              * to the next QEMU_CLOCK_VIRTUAL event and notify it.
 474              * It is useful when we want a deterministic execution time,
 475              * isolated from host latencies.
 476              */
 477             seqlock_write_begin(&timers_state.vm_clock_seqlock);
 478             timers_state.qemu_icount_bias += deadline;
 479             seqlock_write_end(&timers_state.vm_clock_seqlock);
 480             qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
 481         } else {
 482             /*
 483              * We do stop VCPUs and only advance QEMU_CLOCK_VIRTUAL after some
 484              * "real" time, (related to the time left until the next event) has
 485              * passed. The QEMU_CLOCK_VIRTUAL_RT clock will do this.
 486              * This avoids that the warps are visible externally; for example,
 487              * you will not be sending network packets continuously instead of
 488              * every 100ms.
 489              */
 490             seqlock_write_begin(&timers_state.vm_clock_seqlock);
 491             if (vm_clock_warp_start == -1 || vm_clock_warp_start > clock) {
 492                 vm_clock_warp_start = clock;
 493             }
 494             seqlock_write_end(&timers_state.vm_clock_seqlock);
 495             timer_mod_anticipate(icount_warp_timer, clock + deadline);
 496         }
 497     } else if (deadline == 0) {
 498         qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
 499     }
 500 }
 501
 502 static void qemu_account_warp_timer(void)
 503 {
 504     if (!use_icount || !icount_sleep) {
 505         return;
 506     }
 507
 508     /* Nothing to do if the VM is stopped: QEMU_CLOCK_VIRTUAL timers
 509      * do not fire, so computing the deadline does not make sense.
 510      */
 511     if (!runstate_is_running()) {
 512         return;
 513     }
 514
 515     /* warp clock deterministically in record/replay mode */
 516     if (!replay_checkpoint(CHECKPOINT_CLOCK_WARP_ACCOUNT)) {
 517         return;
 518     }
 519
 520     timer_del(icount_warp_timer);
 521     icount_warp_rt();
 522 }
 523
 524 static bool icount_state_needed(void *opaque)
 525 {
 526     return use_icount;
 527 }
 528
 529 /*
 530  * This is a subsection for icount migration.
 531  */
 532 static const VMStateDescription icount_vmstate_timers = {
 533     .name = "timer/icount",
 534     .version_id = 1,
 535     .minimum_version_id = 1,
 536     .needed = icount_state_needed,
 537     .fields = (VMStateField[]) {
 538         VMSTATE_INT64(qemu_icount_bias, TimersState),
 539         VMSTATE_INT64(qemu_icount, TimersState),
 540         VMSTATE_END_OF_LIST()
 541     }
 542 };
 543
 544 static const VMStateDescription vmstate_timers = {
 545     .name = "timer",
 546     .version_id = 2,
 547     .minimum_version_id = 1,
 548     .fields = (VMStateField[]) {
 549         VMSTATE_INT64(cpu_ticks_offset, TimersState),
 550         VMSTATE_INT64(dummy, TimersState),
 551         VMSTATE_INT64_V(cpu_clock_offset, TimersState, 2),
 552         VMSTATE_END_OF_LIST()
 553     },
 554     .subsections = (const VMStateDescription*[]) {
 555         &icount_vmstate_timers,
 556         NULL
 557     }
 558 };
 559
 560 static void cpu_throttle_thread(void *opaque)
 561 {
 562     CPUState *cpu = opaque;
 563     double pct;
 564     double throttle_ratio;
 565     long sleeptime_ns;
 566
 567     if (!cpu_throttle_get_percentage()) {
 568         return;
 569     }
 570
 571     pct = (double)cpu_throttle_get_percentage()/100;
 572     throttle_ratio = pct / (1 - pct);
 573     sleeptime_ns = (long)(throttle_ratio * CPU_THROTTLE_TIMESLICE_NS);
 574
 575     qemu_mutex_unlock_iothread();
 576     atomic_set(&cpu->throttle_thread_scheduled, 0);
 577     g_usleep(sleeptime_ns / 1000); /* Convert ns to us for usleep call */
 578     qemu_mutex_lock_iothread();
 579 }
 580
 581 static void cpu_throttle_timer_tick(void *opaque)
 582 {
 583     CPUState *cpu;
 584     double pct;
 585
 586     /* Stop the timer if needed */
 587     if (!cpu_throttle_get_percentage()) {
 588         return;
 589     }
 590     CPU_FOREACH(cpu) {
 591         if (!atomic_xchg(&cpu->throttle_thread_scheduled, 1)) {
 592             async_run_on_cpu(cpu, cpu_throttle_thread, cpu);
 593         }
 594     }
 595
 596     pct = (double)cpu_throttle_get_percentage()/100;
 597     timer_mod(throttle_timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT) +
 598                                    CPU_THROTTLE_TIMESLICE_NS / (1-pct));
 599 }
 600
 601 void cpu_throttle_set(int new_throttle_pct)
 602 {
 603     /* Ensure throttle percentage is within valid range */
 604     new_throttle_pct = MIN(new_throttle_pct, CPU_THROTTLE_PCT_MAX);
 605     new_throttle_pct = MAX(new_throttle_pct, CPU_THROTTLE_PCT_MIN);
 606
 607     atomic_set(&throttle_percentage, new_throttle_pct);
 608
 609     timer_mod(throttle_timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT) +
 610                                        CPU_THROTTLE_TIMESLICE_NS);
 611 }
 612
 613 void cpu_throttle_stop(void)
 614 {
 615     atomic_set(&throttle_percentage, 0);
 616 }
 617
 618 bool cpu_throttle_active(void)
 619 {
 620     return (cpu_throttle_get_percentage() != 0);
 621 }
 622
 623 int cpu_throttle_get_percentage(void)
 624 {
 625     return atomic_read(&throttle_percentage);
 626 }
 627
 628 void cpu_ticks_init(void)
 629 {
 630     seqlock_init(&timers_state.vm_clock_seqlock);
 631     vmstate_register(NULL, 0, &vmstate_timers, &timers_state);
 632     throttle_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL_RT,
 633                                            cpu_throttle_timer_tick, NULL);
 634 }
 635
 636 void configure_icount(QemuOpts *opts, Error **errp)
 637 {
 638     const char *option;
 639     char *rem_str = NULL;
 640
 641     option = qemu_opt_get(opts, "shift");
 642     if (!option) {
 643         if (qemu_opt_get(opts, "align") != NULL) {
 644             error_setg(errp, "Please specify shift option when using align");
 645         }
 646         return;
 647     }
 648
 649     icount_sleep = qemu_opt_get_bool(opts, "sleep", true);
 650     if (icount_sleep) {
 651         icount_warp_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL_RT,
 652                                          icount_timer_cb, NULL);
 653     }
 654
 655     icount_align_option = qemu_opt_get_bool(opts, "align", false);
 656
 657     if (icount_align_option && !icount_sleep) {
 658         error_setg(errp, "align=on and sleep=off are incompatible");
 659     }
 660     if (strcmp(option, "auto") != 0) {
 661         errno = 0;
 662         icount_time_shift = strtol(option, &rem_str, 0);
 663         if (errno != 0 || *rem_str != '\0' || !strlen(option)) {
 664             error_setg(errp, "icount: Invalid shift value");
 665         }
 666         use_icount = 1;
 667         return;
 668     } else if (icount_align_option) {
 669         error_setg(errp, "shift=auto and align=on are incompatible");
 670     } else if (!icount_sleep) {
 671         error_setg(errp, "shift=auto and sleep=off are incompatible");
 672     }
 673
 674     use_icount = 2;
 675
 676     /* 125MIPS seems a reasonable initial guess at the guest speed.
 677        It will be corrected fairly quickly anyway.  */
 678     icount_time_shift = 3;
 679
 680     /* Have both realtime and virtual time triggers for speed adjustment.
 681        The realtime trigger catches emulated time passing too slowly,
 682        the virtual time trigger catches emulated time passing too fast.
 683        Realtime triggers occur even when idle, so use them less frequently
 684        than VM triggers.  */
 685     icount_rt_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL_RT,
 686                                    icount_adjust_rt, NULL);
 687     timer_mod(icount_rt_timer,
 688                    qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT) + 1000);
 689     icount_vm_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
 690                                         icount_adjust_vm, NULL);
 691     timer_mod(icount_vm_timer,
 692                    qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
 693                    NANOSECONDS_PER_SECOND / 10);
 694 }
 695
 696 /***********************************************************/
 697 void hw_error(const char *fmt, ...)
 698 {
 699     va_list ap;
 700     CPUState *cpu;
 701
 702     va_start(ap, fmt);
 703     fprintf(stderr, "qemu: hardware error: ");
 704     vfprintf(stderr, fmt, ap);
 705     fprintf(stderr, "\n");
 706     CPU_FOREACH(cpu) {
 707         fprintf(stderr, "CPU #%d:\n", cpu->cpu_index);
 708         cpu_dump_state(cpu, stderr, fprintf, CPU_DUMP_FPU);
 709     }
 710     va_end(ap);
 711     abort();
 712 }
 713
 714 void cpu_synchronize_all_states(void)
 715 {
 716     CPUState *cpu;
 717
 718     CPU_FOREACH(cpu) {
 719         cpu_synchronize_state(cpu);
 720     }
 721 }
 722
 723 void cpu_synchronize_all_post_reset(void)
 724 {
 725     CPUState *cpu;
 726
 727     CPU_FOREACH(cpu) {
 728         cpu_synchronize_post_reset(cpu);
 729     }
 730 }
 731
 732 void cpu_synchronize_all_post_init(void)
 733 {
 734     CPUState *cpu;
 735
 736     CPU_FOREACH(cpu) {
 737         cpu_synchronize_post_init(cpu);
 738     }
 739 }
 740
 741 static int do_vm_stop(RunState state)
 742 {
 743     int ret = 0;
 744
 745     if (runstate_is_running()) {
 746         cpu_disable_ticks();
 747         pause_all_vcpus();
 748         runstate_set(state);
 749         vm_state_notify(0, state);
 750         qapi_event_send_stop(&error_abort);
 751     }
 752
 753     bdrv_drain_all();
 754     ret = blk_flush_all();
 755
 756     return ret;
 757 }
 758
 759 static bool cpu_can_run(CPUState *cpu)
 760 {
 761     if (cpu->stop) {
 762         return false;
 763     }
 764     if (cpu_is_stopped(cpu)) {
 765         return false;
 766     }
 767     return true;
 768 }
 769
 770 static void cpu_handle_guest_debug(CPUState *cpu)
 771 {
 772     gdb_set_stop_cpu(cpu);
 773     qemu_system_debug_request();
 774     cpu->stopped = true;
 775 }
 776
 777 #ifdef CONFIG_LINUX
 778 static void sigbus_reraise(void)
 779 {
 780     sigset_t set;
 781     struct sigaction action;
 782
 783     memset(&action, 0, sizeof(action));
 784     action.sa_handler = SIG_DFL;
 785     if (!sigaction(SIGBUS, &action, NULL)) {
 786         raise(SIGBUS);
 787         sigemptyset(&set);
 788         sigaddset(&set, SIGBUS);
 789         pthread_sigmask(SIG_UNBLOCK, &set, NULL);
 790     }
 791     perror("Failed to re-raise SIGBUS!\n");
 792     abort();
 793 }
 794
 795 static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo,
 796                            void *ctx)
 797 {
 798     if (kvm_on_sigbus(siginfo->ssi_code,
 799                       (void *)(intptr_t)siginfo->ssi_addr)) {
 800         sigbus_reraise();
 801     }
 802 }
 803
 804 static void qemu_init_sigbus(void)
 805 {
 806     struct sigaction action;
 807
 808     memset(&action, 0, sizeof(action));
 809     action.sa_flags = SA_SIGINFO;
 810     action.sa_sigaction = (void (*)(int, siginfo_t*, void*))sigbus_handler;
 811     sigaction(SIGBUS, &action, NULL);
 812
 813     prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, 0, 0);
 814 }
 815
 816 static void qemu_kvm_eat_signals(CPUState *cpu)
 817 {
 818     struct timespec ts = { 0, 0 };
 819     siginfo_t siginfo;
 820     sigset_t waitset;
 821     sigset_t chkset;
 822     int r;
 823
 824     sigemptyset(&waitset);
 825     sigaddset(&waitset, SIG_IPI);
 826     sigaddset(&waitset, SIGBUS);
 827
 828     do {
 829         r = sigtimedwait(&waitset, &siginfo, &ts);
 830         if (r == -1 && !(errno == EAGAIN || errno == EINTR)) {
 831             perror("sigtimedwait");
 832             exit(1);
 833         }
 834
 835         switch (r) {
 836         case SIGBUS:
 837             if (kvm_on_sigbus_vcpu(cpu, siginfo.si_code, siginfo.si_addr)) {
 838                 sigbus_reraise();
 839             }
 840             break;
 841         default:
 842             break;
 843         }
 844
 845         r = sigpending(&chkset);
 846         if (r == -1) {
 847             perror("sigpending");
 848             exit(1);
 849         }
 850     } while (sigismember(&chkset, SIG_IPI) || sigismember(&chkset, SIGBUS));
 851 }
 852
 853 #else /* !CONFIG_LINUX */
 854
 855 static void qemu_init_sigbus(void)
 856 {
 857 }
 858
 859 static void qemu_kvm_eat_signals(CPUState *cpu)
 860 {
 861 }
 862 #endif /* !CONFIG_LINUX */
 863
 864 #ifndef _WIN32
 865 static void dummy_signal(int sig)
 866 {
 867 }
 868
 869 static void qemu_kvm_init_cpu_signals(CPUState *cpu)
 870 {
 871     int r;
 872     sigset_t set;
 873     struct sigaction sigact;
 874
 875     memset(&sigact, 0, sizeof(sigact));
 876     sigact.sa_handler = dummy_signal;
 877     sigaction(SIG_IPI, &sigact, NULL);
 878
 879     pthread_sigmask(SIG_BLOCK, NULL, &set);
 880     sigdelset(&set, SIG_IPI);
 881     sigdelset(&set, SIGBUS);
 882     r = kvm_set_signal_mask(cpu, &set);
 883     if (r) {
 884         fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));
 885         exit(1);
 886     }
 887 }
 888
 889 #else /* _WIN32 */
 890 static void qemu_kvm_init_cpu_signals(CPUState *cpu)
 891 {
 892     abort();
 893 }
 894 #endif /* _WIN32 */
 895
 896 static QemuMutex qemu_global_mutex;
 897 static QemuCond qemu_io_proceeded_cond;
 898 static unsigned iothread_requesting_mutex;
 899
 900 static QemuThread io_thread;
 901
 902 /* cpu creation */
 903 static QemuCond qemu_cpu_cond;
 904 /* system init */
 905 static QemuCond qemu_pause_cond;
 906 static QemuCond qemu_work_cond;
 907
 908 void qemu_init_cpu_loop(void)
 909 {
 910     qemu_init_sigbus();
 911     qemu_cond_init(&qemu_cpu_cond);
 912     qemu_cond_init(&qemu_pause_cond);
 913     qemu_cond_init(&qemu_work_cond);
 914     qemu_cond_init(&qemu_io_proceeded_cond);
 915     qemu_mutex_init(&qemu_global_mutex);
 916
 917     qemu_thread_get_self(&io_thread);
 918 }
 919
 920 void run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data)
 921 {
 922     struct qemu_work_item wi;
 923
 924     if (qemu_cpu_is_self(cpu)) {
 925         func(data);
 926         return;
 927     }
 928
 929     wi.func = func;
 930     wi.data = data;
 931     wi.free = false;
 932
 933     qemu_mutex_lock(&cpu->work_mutex);
 934     if (cpu->queued_work_first == NULL) {
 935         cpu->queued_work_first = &wi;
 936     } else {
 937         cpu->queued_work_last->next = &wi;
 938     }
 939     cpu->queued_work_last = &wi;
 940     wi.next = NULL;
 941     wi.done = false;
 942     qemu_mutex_unlock(&cpu->work_mutex);
 943
 944     qemu_cpu_kick(cpu);
 945     while (!atomic_mb_read(&wi.done)) {
 946         CPUState *self_cpu = current_cpu;
 947
 948         qemu_cond_wait(&qemu_work_cond, &qemu_global_mutex);
 949         current_cpu = self_cpu;
 950     }
 951 }
 952
 953 void async_run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data)
 954 {
 955     struct qemu_work_item *wi;
 956
 957     if (qemu_cpu_is_self(cpu)) {
 958         func(data);
 959         return;
 960     }
 961
 962     wi = g_malloc0(sizeof(struct qemu_work_item));
 963     wi->func = func;
 964     wi->data = data;
 965     wi->free = true;
 966
 967     qemu_mutex_lock(&cpu->work_mutex);
 968     if (cpu->queued_work_first == NULL) {
 969         cpu->queued_work_first = wi;
 970     } else {
 971         cpu->queued_work_last->next = wi;
 972     }
 973     cpu->queued_work_last = wi;
 974     wi->next = NULL;
 975     wi->done = false;
 976     qemu_mutex_unlock(&cpu->work_mutex);
 977
 978     qemu_cpu_kick(cpu);
 979 }
 980
 981 static void qemu_kvm_destroy_vcpu(CPUState *cpu)
 982 {
 983     if (kvm_destroy_vcpu(cpu) < 0) {
 984         error_report("kvm_destroy_vcpu failed");
 985         exit(EXIT_FAILURE);
 986     }
 987 }
 988
 989 static void qemu_tcg_destroy_vcpu(CPUState *cpu)
 990 {
 991 }
 992
 993 static void flush_queued_work(CPUState *cpu)
 994 {
 995     struct qemu_work_item *wi;
 996
 997     if (cpu->queued_work_first == NULL) {
 998         return;
 999     }
1000
1001     qemu_mutex_lock(&cpu->work_mutex);
1002     while (cpu->queued_work_first != NULL) {
1003         wi = cpu->queued_work_first;
1004         cpu->queued_work_first = wi->next;
1005         if (!cpu->queued_work_first) {
1006             cpu->queued_work_last = NULL;
1007         }
1008         qemu_mutex_unlock(&cpu->work_mutex);
1009         wi->func(wi->data);
1010         qemu_mutex_lock(&cpu->work_mutex);
1011         if (wi->free) {
1012             g_free(wi);
1013         } else {
1014             atomic_mb_set(&wi->done, true);
1015         }
1016     }
1017     qemu_mutex_unlock(&cpu->work_mutex);
1018     qemu_cond_broadcast(&qemu_work_cond);
1019 }
1020
1021 static void qemu_wait_io_event_common(CPUState *cpu)
1022 {
1023     if (cpu->stop) {
1024         cpu->stop = false;
1025         cpu->stopped = true;
1026         qemu_cond_broadcast(&qemu_pause_cond);
1027     }
1028     flush_queued_work(cpu);
1029     cpu->thread_kicked = false;
1030 }
1031
1032 static void qemu_tcg_wait_io_event(CPUState *cpu)
1033 {
1034     while (all_cpu_threads_idle()) {
1035         qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
1036     }
1037
1038     while (iothread_requesting_mutex) {
1039         qemu_cond_wait(&qemu_io_proceeded_cond, &qemu_global_mutex);
1040     }
1041
1042     CPU_FOREACH(cpu) {
1043         qemu_wait_io_event_common(cpu);
1044     }
1045 }
1046
1047 static void qemu_kvm_wait_io_event(CPUState *cpu)
1048 {
1049     while (cpu_thread_is_idle(cpu)) {
1050         qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
1051     }
1052
1053     qemu_kvm_eat_signals(cpu);
1054     qemu_wait_io_event_common(cpu);
1055 }
1056
1057 static void *qemu_kvm_cpu_thread_fn(void *arg)
1058 {
1059     CPUState *cpu = arg;
1060     int r;
1061
1062     rcu_register_thread();
1063
1064     qemu_mutex_lock_iothread();
1065     qemu_thread_get_self(cpu->thread);
1066     cpu->thread_id = qemu_get_thread_id();
1067     cpu->can_do_io = 1;
1068     current_cpu = cpu;
1069
1070     r = kvm_init_vcpu(cpu);
1071     if (r < 0) {
1072         fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r));
1073         exit(1);
1074     }
1075
1076     qemu_kvm_init_cpu_signals(cpu);
1077
1078     /* signal CPU creation */
1079     cpu->created = true;
1080     qemu_cond_signal(&qemu_cpu_cond);
1081
1082     do {
1083         if (cpu_can_run(cpu)) {
1084             r = kvm_cpu_exec(cpu);
1085             if (r == EXCP_DEBUG) {
1086                 cpu_handle_guest_debug(cpu);
1087             }
1088         }
1089         qemu_kvm_wait_io_event(cpu);
1090     } while (!cpu->unplug || cpu_can_run(cpu));
1091
1092     qemu_kvm_destroy_vcpu(cpu);
1093     cpu->created = false;
1094     qemu_cond_signal(&qemu_cpu_cond);
1095     qemu_mutex_unlock_iothread();
1096     return NULL;
1097 }
1098
1099 static void *qemu_dummy_cpu_thread_fn(void *arg)
1100 {
1101 #ifdef _WIN32
1102     fprintf(stderr, "qtest is not supported under Windows\n");
1103     exit(1);
1104 #else
1105     CPUState *cpu = arg;
1106     sigset_t waitset;
1107     int r;
1108
1109     rcu_register_thread();
1110
1111     qemu_mutex_lock_iothread();
1112     qemu_thread_get_self(cpu->thread);
1113     cpu->thread_id = qemu_get_thread_id();
1114     cpu->can_do_io = 1;
1115
1116     sigemptyset(&waitset);
1117     sigaddset(&waitset, SIG_IPI);
1118
1119     /* signal CPU creation */
1120     cpu->created = true;
1121     qemu_cond_signal(&qemu_cpu_cond);
1122
1123     current_cpu = cpu;
1124     while (1) {
1125         current_cpu = NULL;
1126         qemu_mutex_unlock_iothread();
1127         do {
1128             int sig;
1129             r = sigwait(&waitset, &sig);
1130         } while (r == -1 && (errno == EAGAIN || errno == EINTR));
1131         if (r == -1) {
1132             perror("sigwait");
1133             exit(1);
1134         }
1135         qemu_mutex_lock_iothread();
1136         current_cpu = cpu;
1137         qemu_wait_io_event_common(cpu);
1138     }
1139
1140     return NULL;
1141 #endif
1142 }
1143
1144 static void tcg_exec_all(void);
1145
1146 static void *qemu_tcg_cpu_thread_fn(void *arg)
1147 {
1148     CPUState *cpu = arg;
1149     CPUState *remove_cpu = NULL;
1150
1151     rcu_register_thread();
1152
1153     qemu_mutex_lock_iothread();
1154     qemu_thread_get_self(cpu->thread);
1155
1156     CPU_FOREACH(cpu) {
1157         cpu->thread_id = qemu_get_thread_id();
1158         cpu->created = true;
1159         cpu->can_do_io = 1;
1160     }
1161     qemu_cond_signal(&qemu_cpu_cond);
1162
1163     /* wait for initial kick-off after machine start */
1164     while (first_cpu->stopped) {
1165         qemu_cond_wait(first_cpu->halt_cond, &qemu_global_mutex);
1166
1167         /* process any pending work */
1168         CPU_FOREACH(cpu) {
1169             qemu_wait_io_event_common(cpu);
1170         }
1171     }
1172
1173     /* process any pending work */
1174     atomic_mb_set(&exit_request, 1);
1175
1176     while (1) {
1177         tcg_exec_all();
1178
1179         if (use_icount) {
1180             int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
1181
1182             if (deadline == 0) {
1183                 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
1184             }
1185         }
1186         qemu_tcg_wait_io_event(QTAILQ_FIRST(&cpus));
1187         CPU_FOREACH(cpu) {
1188             if (cpu->unplug && !cpu_can_run(cpu)) {
1189                 remove_cpu = cpu;
1190                 break;
1191             }
1192         }
1193         if (remove_cpu) {
1194             qemu_tcg_destroy_vcpu(remove_cpu);
1195             cpu->created = false;
1196             qemu_cond_signal(&qemu_cpu_cond);
1197             remove_cpu = NULL;
1198         }
1199     }
1200
1201     return NULL;
1202 }
1203
1204 static void qemu_cpu_kick_thread(CPUState *cpu)
1205 {
1206 #ifndef _WIN32
1207     int err;
1208
1209     if (cpu->thread_kicked) {
1210         return;
1211     }
1212     cpu->thread_kicked = true;
1213     err = pthread_kill(cpu->thread->thread, SIG_IPI);
1214     if (err) {
1215         fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
1216         exit(1);
1217     }
1218 #else /* _WIN32 */
1219     abort();
1220 #endif
1221 }
1222
1223 static void qemu_cpu_kick_no_halt(void)
1224 {
1225     CPUState *cpu;
1226     /* Ensure whatever caused the exit has reached the CPU threads before
1227      * writing exit_request.
1228      */
1229     atomic_mb_set(&exit_request, 1);
1230     cpu = atomic_mb_read(&tcg_current_cpu);
1231     if (cpu) {
1232         cpu_exit(cpu);
1233     }
1234 }
1235
1236 void qemu_cpu_kick(CPUState *cpu)
1237 {
1238     qemu_cond_broadcast(cpu->halt_cond);
1239     if (tcg_enabled()) {
1240         qemu_cpu_kick_no_halt();
1241     } else {
1242         qemu_cpu_kick_thread(cpu);
1243     }
1244 }
1245
1246 void qemu_cpu_kick_self(void)
1247 {
1248     assert(current_cpu);
1249     qemu_cpu_kick_thread(current_cpu);
1250 }
1251
1252 bool qemu_cpu_is_self(CPUState *cpu)
1253 {
1254     return qemu_thread_is_self(cpu->thread);
1255 }
1256
1257 bool qemu_in_vcpu_thread(void)
1258 {
1259     return current_cpu && qemu_cpu_is_self(current_cpu);
1260 }
1261
1262 static __thread bool iothread_locked = false;
1263
1264 bool qemu_mutex_iothread_locked(void)
1265 {
1266     return iothread_locked;
1267 }
1268
1269 void qemu_mutex_lock_iothread(void)
1270 {
1271     atomic_inc(&iothread_requesting_mutex);
1272     /* In the simple case there is no need to bump the VCPU thread out of
1273      * TCG code execution.
1274      */
1275     if (!tcg_enabled() || qemu_in_vcpu_thread() ||
1276         !first_cpu || !first_cpu->created) {
1277         qemu_mutex_lock(&qemu_global_mutex);
1278         atomic_dec(&iothread_requesting_mutex);
1279     } else {
1280         if (qemu_mutex_trylock(&qemu_global_mutex)) {
1281             qemu_cpu_kick_no_halt();
1282             qemu_mutex_lock(&qemu_global_mutex);
1283         }
1284         atomic_dec(&iothread_requesting_mutex);
1285         qemu_cond_broadcast(&qemu_io_proceeded_cond);
1286     }
1287     iothread_locked = true;
1288 }
1289
1290 void qemu_mutex_unlock_iothread(void)
1291 {
1292     iothread_locked = false;
1293     qemu_mutex_unlock(&qemu_global_mutex);
1294 }
1295
1296 static int all_vcpus_paused(void)
1297 {
1298     CPUState *cpu;
1299
1300     CPU_FOREACH(cpu) {
1301         if (!cpu->stopped) {
1302             return 0;
1303         }
1304     }
1305
1306     return 1;
1307 }
1308
1309 void pause_all_vcpus(void)
1310 {
1311     CPUState *cpu;
1312
1313     qemu_clock_enable(QEMU_CLOCK_VIRTUAL, false);
1314     CPU_FOREACH(cpu) {
1315         cpu->stop = true;
1316         qemu_cpu_kick(cpu);
1317     }
1318
1319     if (qemu_in_vcpu_thread()) {
1320         cpu_stop_current();
1321         if (!kvm_enabled()) {
1322             CPU_FOREACH(cpu) {
1323                 cpu->stop = false;
1324                 cpu->stopped = true;
1325             }
1326             return;
1327         }
1328     }
1329
1330     while (!all_vcpus_paused()) {
1331         qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
1332         CPU_FOREACH(cpu) {
1333             qemu_cpu_kick(cpu);
1334         }
1335     }
1336 }
1337
1338 void cpu_resume(CPUState *cpu)
1339 {
1340     cpu->stop = false;
1341     cpu->stopped = false;
1342     qemu_cpu_kick(cpu);
1343 }
1344
1345 void resume_all_vcpus(void)
1346 {
1347     CPUState *cpu;
1348
1349     qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
1350     CPU_FOREACH(cpu) {
1351         cpu_resume(cpu);
1352     }
1353 }
1354
1355 void cpu_remove(CPUState *cpu)
1356 {
1357     cpu->stop = true;
1358     cpu->unplug = true;
1359     qemu_cpu_kick(cpu);
1360 }
1361
1362 void cpu_remove_sync(CPUState *cpu)
1363 {
1364     cpu_remove(cpu);
1365     while (cpu->created) {
1366         qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1367     }
1368 }
1369
1370 /* For temporary buffers for forming a name */
1371 #define VCPU_THREAD_NAME_SIZE 16
1372
1373 static void qemu_tcg_init_vcpu(CPUState *cpu)
1374 {
1375     char thread_name[VCPU_THREAD_NAME_SIZE];
1376     static QemuCond *tcg_halt_cond;
1377     static QemuThread *tcg_cpu_thread;
1378
1379     /* share a single thread for all cpus with TCG */
1380     if (!tcg_cpu_thread) {
1381         cpu->thread = g_malloc0(sizeof(QemuThread));
1382         cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1383         qemu_cond_init(cpu->halt_cond);
1384         tcg_halt_cond = cpu->halt_cond;
1385         snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/TCG",
1386                  cpu->cpu_index);
1387         qemu_thread_create(cpu->thread, thread_name, qemu_tcg_cpu_thread_fn,
1388                            cpu, QEMU_THREAD_JOINABLE);
1389 #ifdef _WIN32
1390         cpu->hThread = qemu_thread_get_handle(cpu->thread);
1391 #endif
1392         while (!cpu->created) {
1393             qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1394         }
1395         tcg_cpu_thread = cpu->thread;
1396     } else {
1397         cpu->thread = tcg_cpu_thread;
1398         cpu->halt_cond = tcg_halt_cond;
1399     }
1400 }
1401
1402 static void qemu_kvm_start_vcpu(CPUState *cpu)
1403 {
1404     char thread_name[VCPU_THREAD_NAME_SIZE];
1405
1406     cpu->thread = g_malloc0(sizeof(QemuThread));
1407     cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1408     qemu_cond_init(cpu->halt_cond);
1409     snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/KVM",
1410              cpu->cpu_index);
1411     qemu_thread_create(cpu->thread, thread_name, qemu_kvm_cpu_thread_fn,
1412                        cpu, QEMU_THREAD_JOINABLE);
1413     while (!cpu->created) {
1414         qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1415     }
1416 }
1417
1418 static void qemu_dummy_start_vcpu(CPUState *cpu)
1419 {
1420     char thread_name[VCPU_THREAD_NAME_SIZE];
1421
1422     cpu->thread = g_malloc0(sizeof(QemuThread));
1423     cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1424     qemu_cond_init(cpu->halt_cond);
1425     snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/DUMMY",
1426              cpu->cpu_index);
1427     qemu_thread_create(cpu->thread, thread_name, qemu_dummy_cpu_thread_fn, cpu,
1428                        QEMU_THREAD_JOINABLE);
1429     while (!cpu->created) {
1430         qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1431     }
1432 }
1433
1434 void qemu_init_vcpu(CPUState *cpu)
1435 {
1436     cpu->nr_cores = smp_cores;
1437     cpu->nr_threads = smp_threads;
1438     cpu->stopped = true;
1439
1440     if (!cpu->as) {
1441         /* If the target cpu hasn't set up any address spaces itself,
1442          * give it the default one.
1443          */
1444         AddressSpace *as = address_space_init_shareable(cpu->memory,
1445                                                         "cpu-memory");
1446         cpu->num_ases = 1;
1447         cpu_address_space_init(cpu, as, 0);
1448     }
1449
1450     if (kvm_enabled()) {
1451         qemu_kvm_start_vcpu(cpu);
1452     } else if (tcg_enabled()) {
1453         qemu_tcg_init_vcpu(cpu);
1454     } else {
1455         qemu_dummy_start_vcpu(cpu);
1456     }
1457 }
1458
1459 void cpu_stop_current(void)
1460 {
1461     if (current_cpu) {
1462         current_cpu->stop = false;
1463         current_cpu->stopped = true;
1464         cpu_exit(current_cpu);
1465         qemu_cond_broadcast(&qemu_pause_cond);
1466     }
1467 }
1468
1469 int vm_stop(RunState state)
1470 {
1471     if (qemu_in_vcpu_thread()) {
1472         qemu_system_vmstop_request_prepare();
1473         qemu_system_vmstop_request(state);
1474         /*
1475          * FIXME: should not return to device code in case
1476          * vm_stop() has been requested.
1477          */
1478         cpu_stop_current();
1479         return 0;
1480     }
1481
1482     return do_vm_stop(state);
1483 }
1484
1485 /* does a state transition even if the VM is already stopped,
1486    current state is forgotten forever */
1487 int vm_stop_force_state(RunState state)
1488 {
1489     if (runstate_is_running()) {
1490         return vm_stop(state);
1491     } else {
1492         runstate_set(state);
1493
1494         bdrv_drain_all();
1495         /* Make sure to return an error if the flush in a previous vm_stop()
1496          * failed. */
1497         return blk_flush_all();
1498     }
1499 }
1500
1501 static int64_t tcg_get_icount_limit(void)
1502 {
1503     int64_t deadline;
1504
1505     if (replay_mode != REPLAY_MODE_PLAY) {
1506         deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
1507
1508         /* Maintain prior (possibly buggy) behaviour where if no deadline
1509          * was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than
1510          * INT32_MAX nanoseconds ahead, we still use INT32_MAX
1511          * nanoseconds.
1512          */
1513         if ((deadline < 0) || (deadline > INT32_MAX)) {
1514             deadline = INT32_MAX;
1515         }
1516
1517         return qemu_icount_round(deadline);
1518     } else {
1519         return replay_get_instructions();
1520     }
1521 }
1522
1523 static int tcg_cpu_exec(CPUState *cpu)
1524 {
1525     int ret;
1526 #ifdef CONFIG_PROFILER
1527     int64_t ti;
1528 #endif
1529
1530 #ifdef CONFIG_PROFILER
1531     ti = profile_getclock();
1532 #endif
1533     if (use_icount) {
1534         int64_t count;
1535         int decr;
1536         timers_state.qemu_icount -= (cpu->icount_decr.u16.low
1537                                     + cpu->icount_extra);
1538         cpu->icount_decr.u16.low = 0;
1539         cpu->icount_extra = 0;
1540         count = tcg_get_icount_limit();
1541         timers_state.qemu_icount += count;
1542         decr = (count > 0xffff) ? 0xffff : count;
1543         count -= decr;
1544         cpu->icount_decr.u16.low = decr;
1545         cpu->icount_extra = count;
1546     }
1547     ret = cpu_exec(cpu);
1548 #ifdef CONFIG_PROFILER
1549     tcg_time += profile_getclock() - ti;
1550 #endif
1551     if (use_icount) {
1552         /* Fold pending instructions back into the
1553            instruction counter, and clear the interrupt flag.  */
1554         timers_state.qemu_icount -= (cpu->icount_decr.u16.low
1555                         + cpu->icount_extra);
1556         cpu->icount_decr.u32 = 0;
1557         cpu->icount_extra = 0;
1558         replay_account_executed_instructions();
1559     }
1560     return ret;
1561 }
1562
1563 static void tcg_exec_all(void)
1564 {
1565     int r;
1566
1567     /* Account partial waits to QEMU_CLOCK_VIRTUAL.  */
1568     qemu_account_warp_timer();
1569
1570     if (next_cpu == NULL) {
1571         next_cpu = first_cpu;
1572     }
1573     for (; next_cpu != NULL && !exit_request; next_cpu = CPU_NEXT(next_cpu)) {
1574         CPUState *cpu = next_cpu;
1575
1576         qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
1577                           (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);
1578
1579         if (cpu_can_run(cpu)) {
1580             r = tcg_cpu_exec(cpu);
1581             if (r == EXCP_DEBUG) {
1582                 cpu_handle_guest_debug(cpu);
1583                 break;
1584             }
1585         } else if (cpu->stop || cpu->stopped) {
1586             if (cpu->unplug) {
1587                 next_cpu = CPU_NEXT(cpu);
1588             }
1589             break;
1590         }
1591     }
1592
1593     /* Pairs with smp_wmb in qemu_cpu_kick.  */
1594     atomic_mb_set(&exit_request, 0);
1595 }
1596
1597 void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
1598 {
1599     /* XXX: implement xxx_cpu_list for targets that still miss it */
1600 #if defined(cpu_list)
1601     cpu_list(f, cpu_fprintf);
1602 #endif
1603 }
1604
1605 CpuInfoList *qmp_query_cpus(Error **errp)
1606 {
1607     CpuInfoList *head = NULL, *cur_item = NULL;
1608     CPUState *cpu;
1609
1610     CPU_FOREACH(cpu) {
1611         CpuInfoList *info;
1612 #if defined(TARGET_I386)
1613         X86CPU *x86_cpu = X86_CPU(cpu);
1614         CPUX86State *env = &x86_cpu->env;
1615 #elif defined(TARGET_PPC)
1616         PowerPCCPU *ppc_cpu = POWERPC_CPU(cpu);
1617         CPUPPCState *env = &ppc_cpu->env;
1618 #elif defined(TARGET_SPARC)
1619         SPARCCPU *sparc_cpu = SPARC_CPU(cpu);
1620         CPUSPARCState *env = &sparc_cpu->env;
1621 #elif defined(TARGET_MIPS)
1622         MIPSCPU *mips_cpu = MIPS_CPU(cpu);
1623         CPUMIPSState *env = &mips_cpu->env;
1624 #elif defined(TARGET_TRICORE)
1625         TriCoreCPU *tricore_cpu = TRICORE_CPU(cpu);
1626         CPUTriCoreState *env = &tricore_cpu->env;
1627 #endif
1628
1629         cpu_synchronize_state(cpu);
1630
1631         info = g_malloc0(sizeof(*info));
1632         info->value = g_malloc0(sizeof(*info->value));
1633         info->value->CPU = cpu->cpu_index;
1634         info->value->current = (cpu == first_cpu);
1635         info->value->halted = cpu->halted;
1636         info->value->qom_path = object_get_canonical_path(OBJECT(cpu));
1637         info->value->thread_id = cpu->thread_id;
1638 #if defined(TARGET_I386)
1639         info->value->arch = CPU_INFO_ARCH_X86;
1640         info->value->u.x86.pc = env->eip + env->segs[R_CS].base;
1641 #elif defined(TARGET_PPC)
1642         info->value->arch = CPU_INFO_ARCH_PPC;
1643         info->value->u.ppc.nip = env->nip;
1644 #elif defined(TARGET_SPARC)
1645         info->value->arch = CPU_INFO_ARCH_SPARC;
1646         info->value->u.q_sparc.pc = env->pc;
1647         info->value->u.q_sparc.npc = env->npc;
1648 #elif defined(TARGET_MIPS)
1649         info->value->arch = CPU_INFO_ARCH_MIPS;
1650         info->value->u.q_mips.PC = env->active_tc.PC;
1651 #elif defined(TARGET_TRICORE)
1652         info->value->arch = CPU_INFO_ARCH_TRICORE;
1653         info->value->u.tricore.PC = env->PC;
1654 #else
1655         info->value->arch = CPU_INFO_ARCH_OTHER;
1656 #endif
1657
1658         /* XXX: waiting for the qapi to support GSList */
1659         if (!cur_item) {
1660             head = cur_item = info;
1661         } else {
1662             cur_item->next = info;
1663             cur_item = info;
1664         }
1665     }
1666
1667     return head;
1668 }
1669
1670 void qmp_memsave(int64_t addr, int64_t size, const char *filename,
1671                  bool has_cpu, int64_t cpu_index, Error **errp)
1672 {
1673     FILE *f;
1674     uint32_t l;
1675     CPUState *cpu;
1676     uint8_t buf[1024];
1677     int64_t orig_addr = addr, orig_size = size;
1678
1679     if (!has_cpu) {
1680         cpu_index = 0;
1681     }
1682
1683     cpu = qemu_get_cpu(cpu_index);
1684     if (cpu == NULL) {
1685         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
1686                    "a CPU number");
1687         return;
1688     }
1689
1690     f = fopen(filename, "wb");
1691     if (!f) {
1692         error_setg_file_open(errp, errno, filename);
1693         return;
1694     }
1695
1696     while (size != 0) {
1697         l = sizeof(buf);
1698         if (l > size)
1699             l = size;
1700         if (cpu_memory_rw_debug(cpu, addr, buf, l, 0) != 0) {
1701             error_setg(errp, "Invalid addr 0x%016" PRIx64 "/size %" PRId64
1702                              " specified", orig_addr, orig_size);
1703             goto exit;
1704         }
1705         if (fwrite(buf, 1, l, f) != l) {
1706             error_setg(errp, QERR_IO_ERROR);
1707             goto exit;
1708         }
1709         addr += l;
1710         size -= l;
1711     }
1712
1713 exit:
1714     fclose(f);
1715 }
1716
1717 void qmp_pmemsave(int64_t addr, int64_t size, const char *filename,
1718                   Error **errp)
1719 {
1720     FILE *f;
1721     uint32_t l;
1722     uint8_t buf[1024];
1723
1724     f = fopen(filename, "wb");
1725     if (!f) {
1726         error_setg_file_open(errp, errno, filename);
1727         return;
1728     }
1729
1730     while (size != 0) {
1731         l = sizeof(buf);
1732         if (l > size)
1733             l = size;
1734         cpu_physical_memory_read(addr, buf, l);
1735         if (fwrite(buf, 1, l, f) != l) {
1736             error_setg(errp, QERR_IO_ERROR);
1737             goto exit;
1738         }
1739         addr += l;
1740         size -= l;
1741     }
1742
1743 exit:
1744     fclose(f);
1745 }
1746
1747 void qmp_inject_nmi(Error **errp)
1748 {
1749     nmi_monitor_handle(monitor_get_cpu_index(), errp);
1750 }
1751
1752 void dump_drift_info(FILE *f, fprintf_function cpu_fprintf)
1753 {
1754     if (!use_icount) {
1755         return;
1756     }
1757
1758     cpu_fprintf(f, "Host - Guest clock  %"PRIi64" ms\n",
1759                 (cpu_get_clock() - cpu_get_icount())/SCALE_MS);
1760     if (icount_align_option) {
1761         cpu_fprintf(f, "Max guest delay     %"PRIi64" ms\n", -max_delay/SCALE_MS);
1762         cpu_fprintf(f, "Max guest advance   %"PRIi64" ms\n", max_advance/SCALE_MS);
1763     } else {
1764         cpu_fprintf(f, "Max guest delay     NA\n");
1765         cpu_fprintf(f, "Max guest advance   NA\n");
1766     }
1767 }