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