cpus.c

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