cpus.c

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