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 static void cpu_signal(int sig)
 665 {
 666     CPUState *cpu = atomic_mb_read(&tcg_current_cpu);
 667     if (cpu) {
 668         cpu_exit(cpu);
 669     }
 670     exit_request = 1;
 671 }
 672
 673 #ifdef CONFIG_LINUX
 674 static void sigbus_reraise(void)
 675 {
 676     sigset_t set;
 677     struct sigaction action;
 678
 679     memset(&action, 0, sizeof(action));
 680     action.sa_handler = SIG_DFL;
 681     if (!sigaction(SIGBUS, &action, NULL)) {
 682         raise(SIGBUS);
 683         sigemptyset(&set);
 684         sigaddset(&set, SIGBUS);
 685         sigprocmask(SIG_UNBLOCK, &set, NULL);
 686     }
 687     perror("Failed to re-raise SIGBUS!\n");
 688     abort();
 689 }
 690
 691 static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo,
 692                            void *ctx)
 693 {
 694     if (kvm_on_sigbus(siginfo->ssi_code,
 695                       (void *)(intptr_t)siginfo->ssi_addr)) {
 696         sigbus_reraise();
 697     }
 698 }
 699
 700 static void qemu_init_sigbus(void)
 701 {
 702     struct sigaction action;
 703
 704     memset(&action, 0, sizeof(action));
 705     action.sa_flags = SA_SIGINFO;
 706     action.sa_sigaction = (void (*)(int, siginfo_t*, void*))sigbus_handler;
 707     sigaction(SIGBUS, &action, NULL);
 708
 709     prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, 0, 0);
 710 }
 711
 712 static void qemu_kvm_eat_signals(CPUState *cpu)
 713 {
 714     struct timespec ts = { 0, 0 };
 715     siginfo_t siginfo;
 716     sigset_t waitset;
 717     sigset_t chkset;
 718     int r;
 719
 720     sigemptyset(&waitset);
 721     sigaddset(&waitset, SIG_IPI);
 722     sigaddset(&waitset, SIGBUS);
 723
 724     do {
 725         r = sigtimedwait(&waitset, &siginfo, &ts);
 726         if (r == -1 && !(errno == EAGAIN || errno == EINTR)) {
 727             perror("sigtimedwait");
 728             exit(1);
 729         }
 730
 731         switch (r) {
 732         case SIGBUS:
 733             if (kvm_on_sigbus_vcpu(cpu, siginfo.si_code, siginfo.si_addr)) {
 734                 sigbus_reraise();
 735             }
 736             break;
 737         default:
 738             break;
 739         }
 740
 741         r = sigpending(&chkset);
 742         if (r == -1) {
 743             perror("sigpending");
 744             exit(1);
 745         }
 746     } while (sigismember(&chkset, SIG_IPI) || sigismember(&chkset, SIGBUS));
 747 }
 748
 749 #else /* !CONFIG_LINUX */
 750
 751 static void qemu_init_sigbus(void)
 752 {
 753 }
 754
 755 static void qemu_kvm_eat_signals(CPUState *cpu)
 756 {
 757 }
 758 #endif /* !CONFIG_LINUX */
 759
 760 #ifndef _WIN32
 761 static void dummy_signal(int sig)
 762 {
 763 }
 764
 765 static void qemu_kvm_init_cpu_signals(CPUState *cpu)
 766 {
 767     int r;
 768     sigset_t set;
 769     struct sigaction sigact;
 770
 771     memset(&sigact, 0, sizeof(sigact));
 772     sigact.sa_handler = dummy_signal;
 773     sigaction(SIG_IPI, &sigact, NULL);
 774
 775     pthread_sigmask(SIG_BLOCK, NULL, &set);
 776     sigdelset(&set, SIG_IPI);
 777     sigdelset(&set, SIGBUS);
 778     r = kvm_set_signal_mask(cpu, &set);
 779     if (r) {
 780         fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));
 781         exit(1);
 782     }
 783 }
 784
 785 static void qemu_tcg_init_cpu_signals(void)
 786 {
 787     sigset_t set;
 788     struct sigaction sigact;
 789
 790     memset(&sigact, 0, sizeof(sigact));
 791     sigact.sa_handler = cpu_signal;
 792     sigaction(SIG_IPI, &sigact, NULL);
 793
 794     sigemptyset(&set);
 795     sigaddset(&set, SIG_IPI);
 796     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
 797 }
 798
 799 #else /* _WIN32 */
 800 static void qemu_kvm_init_cpu_signals(CPUState *cpu)
 801 {
 802     abort();
 803 }
 804
 805 static void qemu_tcg_init_cpu_signals(void)
 806 {
 807 }
 808 #endif /* _WIN32 */
 809
 810 static QemuMutex qemu_global_mutex;
 811 static QemuCond qemu_io_proceeded_cond;
 812 static unsigned iothread_requesting_mutex;
 813
 814 static QemuThread io_thread;
 815
 816 static QemuThread *tcg_cpu_thread;
 817 static QemuCond *tcg_halt_cond;
 818
 819 /* cpu creation */
 820 static QemuCond qemu_cpu_cond;
 821 /* system init */
 822 static QemuCond qemu_pause_cond;
 823 static QemuCond qemu_work_cond;
 824
 825 void qemu_init_cpu_loop(void)
 826 {
 827     qemu_init_sigbus();
 828     qemu_cond_init(&qemu_cpu_cond);
 829     qemu_cond_init(&qemu_pause_cond);
 830     qemu_cond_init(&qemu_work_cond);
 831     qemu_cond_init(&qemu_io_proceeded_cond);
 832     qemu_mutex_init(&qemu_global_mutex);
 833
 834     qemu_thread_get_self(&io_thread);
 835 }
 836
 837 void run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data)
 838 {
 839     struct qemu_work_item wi;
 840
 841     if (qemu_cpu_is_self(cpu)) {
 842         func(data);
 843         return;
 844     }
 845
 846     wi.func = func;
 847     wi.data = data;
 848     wi.free = false;
 849     if (cpu->queued_work_first == NULL) {
 850         cpu->queued_work_first = &wi;
 851     } else {
 852         cpu->queued_work_last->next = &wi;
 853     }
 854     cpu->queued_work_last = &wi;
 855     wi.next = NULL;
 856     wi.done = false;
 857
 858     qemu_cpu_kick(cpu);
 859     while (!wi.done) {
 860         CPUState *self_cpu = current_cpu;
 861
 862         qemu_cond_wait(&qemu_work_cond, &qemu_global_mutex);
 863         current_cpu = self_cpu;
 864     }
 865 }
 866
 867 void async_run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data)
 868 {
 869     struct qemu_work_item *wi;
 870
 871     if (qemu_cpu_is_self(cpu)) {
 872         func(data);
 873         return;
 874     }
 875
 876     wi = g_malloc0(sizeof(struct qemu_work_item));
 877     wi->func = func;
 878     wi->data = data;
 879     wi->free = true;
 880     if (cpu->queued_work_first == NULL) {
 881         cpu->queued_work_first = wi;
 882     } else {
 883         cpu->queued_work_last->next = wi;
 884     }
 885     cpu->queued_work_last = wi;
 886     wi->next = NULL;
 887     wi->done = false;
 888
 889     qemu_cpu_kick(cpu);
 890 }
 891
 892 static void flush_queued_work(CPUState *cpu)
 893 {
 894     struct qemu_work_item *wi;
 895
 896     if (cpu->queued_work_first == NULL) {
 897         return;
 898     }
 899
 900     while ((wi = cpu->queued_work_first)) {
 901         cpu->queued_work_first = wi->next;
 902         wi->func(wi->data);
 903         wi->done = true;
 904         if (wi->free) {
 905             g_free(wi);
 906         }
 907     }
 908     cpu->queued_work_last = NULL;
 909     qemu_cond_broadcast(&qemu_work_cond);
 910 }
 911
 912 static void qemu_wait_io_event_common(CPUState *cpu)
 913 {
 914     if (cpu->stop) {
 915         cpu->stop = false;
 916         cpu->stopped = true;
 917         qemu_cond_signal(&qemu_pause_cond);
 918     }
 919     flush_queued_work(cpu);
 920     cpu->thread_kicked = false;
 921 }
 922
 923 static void qemu_tcg_wait_io_event(void)
 924 {
 925     CPUState *cpu;
 926
 927     while (all_cpu_threads_idle()) {
 928        /* Start accounting real time to the virtual clock if the CPUs
 929           are idle.  */
 930         qemu_clock_warp(QEMU_CLOCK_VIRTUAL);
 931         qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
 932     }
 933
 934     while (iothread_requesting_mutex) {
 935         qemu_cond_wait(&qemu_io_proceeded_cond, &qemu_global_mutex);
 936     }
 937
 938     CPU_FOREACH(cpu) {
 939         qemu_wait_io_event_common(cpu);
 940     }
 941 }
 942
 943 static void qemu_kvm_wait_io_event(CPUState *cpu)
 944 {
 945     while (cpu_thread_is_idle(cpu)) {
 946         qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
 947     }
 948
 949     qemu_kvm_eat_signals(cpu);
 950     qemu_wait_io_event_common(cpu);
 951 }
 952
 953 static void *qemu_kvm_cpu_thread_fn(void *arg)
 954 {
 955     CPUState *cpu = arg;
 956     int r;
 957
 958     rcu_register_thread();
 959
 960     qemu_mutex_lock_iothread();
 961     qemu_thread_get_self(cpu->thread);
 962     cpu->thread_id = qemu_get_thread_id();
 963     cpu->can_do_io = 1;
 964     current_cpu = cpu;
 965
 966     r = kvm_init_vcpu(cpu);
 967     if (r < 0) {
 968         fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r));
 969         exit(1);
 970     }
 971
 972     qemu_kvm_init_cpu_signals(cpu);
 973
 974     /* signal CPU creation */
 975     cpu->created = true;
 976     qemu_cond_signal(&qemu_cpu_cond);
 977
 978     while (1) {
 979         if (cpu_can_run(cpu)) {
 980             r = kvm_cpu_exec(cpu);
 981             if (r == EXCP_DEBUG) {
 982                 cpu_handle_guest_debug(cpu);
 983             }
 984         }
 985         qemu_kvm_wait_io_event(cpu);
 986     }
 987
 988     return NULL;
 989 }
 990
 991 static void *qemu_dummy_cpu_thread_fn(void *arg)
 992 {
 993 #ifdef _WIN32
 994     fprintf(stderr, "qtest is not supported under Windows\n");
 995     exit(1);
 996 #else
 997     CPUState *cpu = arg;
 998     sigset_t waitset;
 999     int r;
1000
1001     rcu_register_thread();
1002
1003     qemu_mutex_lock_iothread();
1004     qemu_thread_get_self(cpu->thread);
1005     cpu->thread_id = qemu_get_thread_id();
1006     cpu->can_do_io = 1;
1007
1008     sigemptyset(&waitset);
1009     sigaddset(&waitset, SIG_IPI);
1010
1011     /* signal CPU creation */
1012     cpu->created = true;
1013     qemu_cond_signal(&qemu_cpu_cond);
1014
1015     current_cpu = cpu;
1016     while (1) {
1017         current_cpu = NULL;
1018         qemu_mutex_unlock_iothread();
1019         do {
1020             int sig;
1021             r = sigwait(&waitset, &sig);
1022         } while (r == -1 && (errno == EAGAIN || errno == EINTR));
1023         if (r == -1) {
1024             perror("sigwait");
1025             exit(1);
1026         }
1027         qemu_mutex_lock_iothread();
1028         current_cpu = cpu;
1029         qemu_wait_io_event_common(cpu);
1030     }
1031
1032     return NULL;
1033 #endif
1034 }
1035
1036 static void tcg_exec_all(void);
1037
1038 static void *qemu_tcg_cpu_thread_fn(void *arg)
1039 {
1040     CPUState *cpu = arg;
1041
1042     rcu_register_thread();
1043
1044     qemu_mutex_lock_iothread();
1045     qemu_tcg_init_cpu_signals();
1046     qemu_thread_get_self(cpu->thread);
1047
1048     CPU_FOREACH(cpu) {
1049         cpu->thread_id = qemu_get_thread_id();
1050         cpu->created = true;
1051         cpu->can_do_io = 1;
1052     }
1053     qemu_cond_signal(&qemu_cpu_cond);
1054
1055     /* wait for initial kick-off after machine start */
1056     while (first_cpu->stopped) {
1057         qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
1058
1059         /* process any pending work */
1060         CPU_FOREACH(cpu) {
1061             qemu_wait_io_event_common(cpu);
1062         }
1063     }
1064
1065     /* process any pending work */
1066     exit_request = 1;
1067
1068     while (1) {
1069         tcg_exec_all();
1070
1071         if (use_icount) {
1072             int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
1073
1074             if (deadline == 0) {
1075                 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
1076             }
1077         }
1078         qemu_tcg_wait_io_event();
1079     }
1080
1081     return NULL;
1082 }
1083
1084 static void qemu_cpu_kick_thread(CPUState *cpu)
1085 {
1086 #ifndef _WIN32
1087     int err;
1088
1089     err = pthread_kill(cpu->thread->thread, SIG_IPI);
1090     if (err) {
1091         fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
1092         exit(1);
1093     }
1094 #else /* _WIN32 */
1095     if (!qemu_cpu_is_self(cpu)) {
1096         CONTEXT tcgContext;
1097
1098         if (SuspendThread(cpu->hThread) == (DWORD)-1) {
1099             fprintf(stderr, "qemu:%s: GetLastError:%lu\n", __func__,
1100                     GetLastError());
1101             exit(1);
1102         }
1103
1104         /* On multi-core systems, we are not sure that the thread is actually
1105          * suspended until we can get the context.
1106          */
1107         tcgContext.ContextFlags = CONTEXT_CONTROL;
1108         while (GetThreadContext(cpu->hThread, &tcgContext) != 0) {
1109             continue;
1110         }
1111
1112         cpu_signal(0);
1113
1114         if (ResumeThread(cpu->hThread) == (DWORD)-1) {
1115             fprintf(stderr, "qemu:%s: GetLastError:%lu\n", __func__,
1116                     GetLastError());
1117             exit(1);
1118         }
1119     }
1120 #endif
1121 }
1122
1123 void qemu_cpu_kick(CPUState *cpu)
1124 {
1125     qemu_cond_broadcast(cpu->halt_cond);
1126     if (!tcg_enabled() && !cpu->thread_kicked) {
1127         qemu_cpu_kick_thread(cpu);
1128         cpu->thread_kicked = true;
1129     }
1130 }
1131
1132 void qemu_cpu_kick_self(void)
1133 {
1134 #ifndef _WIN32
1135     assert(current_cpu);
1136
1137     if (!current_cpu->thread_kicked) {
1138         qemu_cpu_kick_thread(current_cpu);
1139         current_cpu->thread_kicked = true;
1140     }
1141 #else
1142     abort();
1143 #endif
1144 }
1145
1146 bool qemu_cpu_is_self(CPUState *cpu)
1147 {
1148     return qemu_thread_is_self(cpu->thread);
1149 }
1150
1151 bool qemu_in_vcpu_thread(void)
1152 {
1153     return current_cpu && qemu_cpu_is_self(current_cpu);
1154 }
1155
1156 static __thread bool iothread_locked = false;
1157
1158 bool qemu_mutex_iothread_locked(void)
1159 {
1160     return iothread_locked;
1161 }
1162
1163 void qemu_mutex_lock_iothread(void)
1164 {
1165     atomic_inc(&iothread_requesting_mutex);
1166     /* In the simple case there is no need to bump the VCPU thread out of
1167      * TCG code execution.
1168      */
1169     if (!tcg_enabled() || qemu_in_vcpu_thread() ||
1170         !first_cpu || !first_cpu->created) {
1171         qemu_mutex_lock(&qemu_global_mutex);
1172         atomic_dec(&iothread_requesting_mutex);
1173     } else {
1174         if (qemu_mutex_trylock(&qemu_global_mutex)) {
1175             qemu_cpu_kick_thread(first_cpu);
1176             qemu_mutex_lock(&qemu_global_mutex);
1177         }
1178         atomic_dec(&iothread_requesting_mutex);
1179         qemu_cond_broadcast(&qemu_io_proceeded_cond);
1180     }
1181     iothread_locked = true;
1182 }
1183
1184 void qemu_mutex_unlock_iothread(void)
1185 {
1186     iothread_locked = false;
1187     qemu_mutex_unlock(&qemu_global_mutex);
1188 }
1189
1190 static int all_vcpus_paused(void)
1191 {
1192     CPUState *cpu;
1193
1194     CPU_FOREACH(cpu) {
1195         if (!cpu->stopped) {
1196             return 0;
1197         }
1198     }
1199
1200     return 1;
1201 }
1202
1203 void pause_all_vcpus(void)
1204 {
1205     CPUState *cpu;
1206
1207     qemu_clock_enable(QEMU_CLOCK_VIRTUAL, false);
1208     CPU_FOREACH(cpu) {
1209         cpu->stop = true;
1210         qemu_cpu_kick(cpu);
1211     }
1212
1213     if (qemu_in_vcpu_thread()) {
1214         cpu_stop_current();
1215         if (!kvm_enabled()) {
1216             CPU_FOREACH(cpu) {
1217                 cpu->stop = false;
1218                 cpu->stopped = true;
1219             }
1220             return;
1221         }
1222     }
1223
1224     while (!all_vcpus_paused()) {
1225         qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
1226         CPU_FOREACH(cpu) {
1227             qemu_cpu_kick(cpu);
1228         }
1229     }
1230 }
1231
1232 void cpu_resume(CPUState *cpu)
1233 {
1234     cpu->stop = false;
1235     cpu->stopped = false;
1236     qemu_cpu_kick(cpu);
1237 }
1238
1239 void resume_all_vcpus(void)
1240 {
1241     CPUState *cpu;
1242
1243     qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
1244     CPU_FOREACH(cpu) {
1245         cpu_resume(cpu);
1246     }
1247 }
1248
1249 /* For temporary buffers for forming a name */
1250 #define VCPU_THREAD_NAME_SIZE 16
1251
1252 static void qemu_tcg_init_vcpu(CPUState *cpu)
1253 {
1254     char thread_name[VCPU_THREAD_NAME_SIZE];
1255
1256     tcg_cpu_address_space_init(cpu, cpu->as);
1257
1258     /* share a single thread for all cpus with TCG */
1259     if (!tcg_cpu_thread) {
1260         cpu->thread = g_malloc0(sizeof(QemuThread));
1261         cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1262         qemu_cond_init(cpu->halt_cond);
1263         tcg_halt_cond = cpu->halt_cond;
1264         snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/TCG",
1265                  cpu->cpu_index);
1266         qemu_thread_create(cpu->thread, thread_name, qemu_tcg_cpu_thread_fn,
1267                            cpu, QEMU_THREAD_JOINABLE);
1268 #ifdef _WIN32
1269         cpu->hThread = qemu_thread_get_handle(cpu->thread);
1270 #endif
1271         while (!cpu->created) {
1272             qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1273         }
1274         tcg_cpu_thread = cpu->thread;
1275     } else {
1276         cpu->thread = tcg_cpu_thread;
1277         cpu->halt_cond = tcg_halt_cond;
1278     }
1279 }
1280
1281 static void qemu_kvm_start_vcpu(CPUState *cpu)
1282 {
1283     char thread_name[VCPU_THREAD_NAME_SIZE];
1284
1285     cpu->thread = g_malloc0(sizeof(QemuThread));
1286     cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1287     qemu_cond_init(cpu->halt_cond);
1288     snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/KVM",
1289              cpu->cpu_index);
1290     qemu_thread_create(cpu->thread, thread_name, qemu_kvm_cpu_thread_fn,
1291                        cpu, QEMU_THREAD_JOINABLE);
1292     while (!cpu->created) {
1293         qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1294     }
1295 }
1296
1297 static void qemu_dummy_start_vcpu(CPUState *cpu)
1298 {
1299     char thread_name[VCPU_THREAD_NAME_SIZE];
1300
1301     cpu->thread = g_malloc0(sizeof(QemuThread));
1302     cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1303     qemu_cond_init(cpu->halt_cond);
1304     snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/DUMMY",
1305              cpu->cpu_index);
1306     qemu_thread_create(cpu->thread, thread_name, qemu_dummy_cpu_thread_fn, cpu,
1307                        QEMU_THREAD_JOINABLE);
1308     while (!cpu->created) {
1309         qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1310     }
1311 }
1312
1313 void qemu_init_vcpu(CPUState *cpu)
1314 {
1315     cpu->nr_cores = smp_cores;
1316     cpu->nr_threads = smp_threads;
1317     cpu->stopped = true;
1318     if (kvm_enabled()) {
1319         qemu_kvm_start_vcpu(cpu);
1320     } else if (tcg_enabled()) {
1321         qemu_tcg_init_vcpu(cpu);
1322     } else {
1323         qemu_dummy_start_vcpu(cpu);
1324     }
1325 }
1326
1327 void cpu_stop_current(void)
1328 {
1329     if (current_cpu) {
1330         current_cpu->stop = false;
1331         current_cpu->stopped = true;
1332         cpu_exit(current_cpu);
1333         qemu_cond_signal(&qemu_pause_cond);
1334     }
1335 }
1336
1337 int vm_stop(RunState state)
1338 {
1339     if (qemu_in_vcpu_thread()) {
1340         qemu_system_vmstop_request_prepare();
1341         qemu_system_vmstop_request(state);
1342         /*
1343          * FIXME: should not return to device code in case
1344          * vm_stop() has been requested.
1345          */
1346         cpu_stop_current();
1347         return 0;
1348     }
1349
1350     return do_vm_stop(state);
1351 }
1352
1353 /* does a state transition even if the VM is already stopped,
1354    current state is forgotten forever */
1355 int vm_stop_force_state(RunState state)
1356 {
1357     if (runstate_is_running()) {
1358         return vm_stop(state);
1359     } else {
1360         runstate_set(state);
1361         /* Make sure to return an error if the flush in a previous vm_stop()
1362          * failed. */
1363         return bdrv_flush_all();
1364     }
1365 }
1366
1367 static int tcg_cpu_exec(CPUState *cpu)
1368 {
1369     int ret;
1370 #ifdef CONFIG_PROFILER
1371     int64_t ti;
1372 #endif
1373
1374 #ifdef CONFIG_PROFILER
1375     ti = profile_getclock();
1376 #endif
1377     if (use_icount) {
1378         int64_t count;
1379         int64_t deadline;
1380         int decr;
1381         timers_state.qemu_icount -= (cpu->icount_decr.u16.low
1382                                     + cpu->icount_extra);
1383         cpu->icount_decr.u16.low = 0;
1384         cpu->icount_extra = 0;
1385         deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
1386
1387         /* Maintain prior (possibly buggy) behaviour where if no deadline
1388          * was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than
1389          * INT32_MAX nanoseconds ahead, we still use INT32_MAX
1390          * nanoseconds.
1391          */
1392         if ((deadline < 0) || (deadline > INT32_MAX)) {
1393             deadline = INT32_MAX;
1394         }
1395
1396         count = qemu_icount_round(deadline);
1397         timers_state.qemu_icount += count;
1398         decr = (count > 0xffff) ? 0xffff : count;
1399         count -= decr;
1400         cpu->icount_decr.u16.low = decr;
1401         cpu->icount_extra = count;
1402     }
1403     ret = cpu_exec(cpu);
1404 #ifdef CONFIG_PROFILER
1405     tcg_time += profile_getclock() - ti;
1406 #endif
1407     if (use_icount) {
1408         /* Fold pending instructions back into the
1409            instruction counter, and clear the interrupt flag.  */
1410         timers_state.qemu_icount -= (cpu->icount_decr.u16.low
1411                         + cpu->icount_extra);
1412         cpu->icount_decr.u32 = 0;
1413         cpu->icount_extra = 0;
1414     }
1415     return ret;
1416 }
1417
1418 static void tcg_exec_all(void)
1419 {
1420     int r;
1421
1422     /* Account partial waits to QEMU_CLOCK_VIRTUAL.  */
1423     qemu_clock_warp(QEMU_CLOCK_VIRTUAL);
1424
1425     if (next_cpu == NULL) {
1426         next_cpu = first_cpu;
1427     }
1428     for (; next_cpu != NULL && !exit_request; next_cpu = CPU_NEXT(next_cpu)) {
1429         CPUState *cpu = next_cpu;
1430
1431         qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
1432                           (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);
1433
1434         if (cpu_can_run(cpu)) {
1435             r = tcg_cpu_exec(cpu);
1436             if (r == EXCP_DEBUG) {
1437                 cpu_handle_guest_debug(cpu);
1438                 break;
1439             }
1440         } else if (cpu->stop || cpu->stopped) {
1441             break;
1442         }
1443     }
1444     exit_request = 0;
1445 }
1446
1447 void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
1448 {
1449     /* XXX: implement xxx_cpu_list for targets that still miss it */
1450 #if defined(cpu_list)
1451     cpu_list(f, cpu_fprintf);
1452 #endif
1453 }
1454
1455 CpuInfoList *qmp_query_cpus(Error **errp)
1456 {
1457     CpuInfoList *head = NULL, *cur_item = NULL;
1458     CPUState *cpu;
1459
1460     CPU_FOREACH(cpu) {
1461         CpuInfoList *info;
1462 #if defined(TARGET_I386)
1463         X86CPU *x86_cpu = X86_CPU(cpu);
1464         CPUX86State *env = &x86_cpu->env;
1465 #elif defined(TARGET_PPC)
1466         PowerPCCPU *ppc_cpu = POWERPC_CPU(cpu);
1467         CPUPPCState *env = &ppc_cpu->env;
1468 #elif defined(TARGET_SPARC)
1469         SPARCCPU *sparc_cpu = SPARC_CPU(cpu);
1470         CPUSPARCState *env = &sparc_cpu->env;
1471 #elif defined(TARGET_MIPS)
1472         MIPSCPU *mips_cpu = MIPS_CPU(cpu);
1473         CPUMIPSState *env = &mips_cpu->env;
1474 #elif defined(TARGET_TRICORE)
1475         TriCoreCPU *tricore_cpu = TRICORE_CPU(cpu);
1476         CPUTriCoreState *env = &tricore_cpu->env;
1477 #endif
1478
1479         cpu_synchronize_state(cpu);
1480
1481         info = g_malloc0(sizeof(*info));
1482         info->value = g_malloc0(sizeof(*info->value));
1483         info->value->CPU = cpu->cpu_index;
1484         info->value->current = (cpu == first_cpu);
1485         info->value->halted = cpu->halted;
1486         info->value->qom_path = object_get_canonical_path(OBJECT(cpu));
1487         info->value->thread_id = cpu->thread_id;
1488 #if defined(TARGET_I386)
1489         info->value->has_pc = true;
1490         info->value->pc = env->eip + env->segs[R_CS].base;
1491 #elif defined(TARGET_PPC)
1492         info->value->has_nip = true;
1493         info->value->nip = env->nip;
1494 #elif defined(TARGET_SPARC)
1495         info->value->has_pc = true;
1496         info->value->pc = env->pc;
1497         info->value->has_npc = true;
1498         info->value->npc = env->npc;
1499 #elif defined(TARGET_MIPS)
1500         info->value->has_PC = true;
1501         info->value->PC = env->active_tc.PC;
1502 #elif defined(TARGET_TRICORE)
1503         info->value->has_PC = true;
1504         info->value->PC = env->PC;
1505 #endif
1506
1507         /* XXX: waiting for the qapi to support GSList */
1508         if (!cur_item) {
1509             head = cur_item = info;
1510         } else {
1511             cur_item->next = info;
1512             cur_item = info;
1513         }
1514     }
1515
1516     return head;
1517 }
1518
1519 void qmp_memsave(int64_t addr, int64_t size, const char *filename,
1520                  bool has_cpu, int64_t cpu_index, Error **errp)
1521 {
1522     FILE *f;
1523     uint32_t l;
1524     CPUState *cpu;
1525     uint8_t buf[1024];
1526     int64_t orig_addr = addr, orig_size = size;
1527
1528     if (!has_cpu) {
1529         cpu_index = 0;
1530     }
1531
1532     cpu = qemu_get_cpu(cpu_index);
1533     if (cpu == NULL) {
1534         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
1535                    "a CPU number");
1536         return;
1537     }
1538
1539     f = fopen(filename, "wb");
1540     if (!f) {
1541         error_setg_file_open(errp, errno, filename);
1542         return;
1543     }
1544
1545     while (size != 0) {
1546         l = sizeof(buf);
1547         if (l > size)
1548             l = size;
1549         if (cpu_memory_rw_debug(cpu, addr, buf, l, 0) != 0) {
1550             error_setg(errp, "Invalid addr 0x%016" PRIx64 "/size %" PRId64
1551                              " specified", orig_addr, orig_size);
1552             goto exit;
1553         }
1554         if (fwrite(buf, 1, l, f) != l) {
1555             error_setg(errp, QERR_IO_ERROR);
1556             goto exit;
1557         }
1558         addr += l;
1559         size -= l;
1560     }
1561
1562 exit:
1563     fclose(f);
1564 }
1565
1566 void qmp_pmemsave(int64_t addr, int64_t size, const char *filename,
1567                   Error **errp)
1568 {
1569     FILE *f;
1570     uint32_t l;
1571     uint8_t buf[1024];
1572
1573     f = fopen(filename, "wb");
1574     if (!f) {
1575         error_setg_file_open(errp, errno, filename);
1576         return;
1577     }
1578
1579     while (size != 0) {
1580         l = sizeof(buf);
1581         if (l > size)
1582             l = size;
1583         cpu_physical_memory_read(addr, buf, l);
1584         if (fwrite(buf, 1, l, f) != l) {
1585             error_setg(errp, QERR_IO_ERROR);
1586             goto exit;
1587         }
1588         addr += l;
1589         size -= l;
1590     }
1591
1592 exit:
1593     fclose(f);
1594 }
1595
1596 void qmp_inject_nmi(Error **errp)
1597 {
1598 #if defined(TARGET_I386)
1599     CPUState *cs;
1600
1601     CPU_FOREACH(cs) {
1602         X86CPU *cpu = X86_CPU(cs);
1603
1604         if (!cpu->apic_state) {
1605             cpu_interrupt(cs, CPU_INTERRUPT_NMI);
1606         } else {
1607             apic_deliver_nmi(cpu->apic_state);
1608         }
1609     }
1610 #else
1611     nmi_monitor_handle(monitor_get_cpu_index(), errp);
1612 #endif
1613 }
1614
1615 void dump_drift_info(FILE *f, fprintf_function cpu_fprintf)
1616 {
1617     if (!use_icount) {
1618         return;
1619     }
1620
1621     cpu_fprintf(f, "Host - Guest clock  %"PRIi64" ms\n",
1622                 (cpu_get_clock() - cpu_get_icount())/SCALE_MS);
1623     if (icount_align_option) {
1624         cpu_fprintf(f, "Max guest delay     %"PRIi64" ms\n", -max_delay/SCALE_MS);
1625         cpu_fprintf(f, "Max guest advance   %"PRIi64" ms\n", max_advance/SCALE_MS);
1626     } else {
1627         cpu_fprintf(f, "Max guest delay     NA\n");
1628         cpu_fprintf(f, "Max guest advance   NA\n");
1629     }
1630 }