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