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