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