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