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     }
 515 }
 516
 517 void cpu_synchronize_all_post_init(void)
 518 {
 519     CPUState *cpu;
 520
 521     CPU_FOREACH(cpu) {
 522         cpu_synchronize_post_init(cpu);
 523     }
 524 }
 525
 526 static int do_vm_stop(RunState state)
 527 {
 528     int ret = 0;
 529
 530     if (runstate_is_running()) {
 531         cpu_disable_ticks();
 532         pause_all_vcpus();
 533         runstate_set(state);
 534         vm_state_notify(0, state);
 535         monitor_protocol_event(QEVENT_STOP, NULL);
 536     }
 537
 538     bdrv_drain_all();
 539     ret = bdrv_flush_all();
 540
 541     return ret;
 542 }
 543
 544 static bool cpu_can_run(CPUState *cpu)
 545 {
 546     if (cpu->stop) {
 547         return false;
 548     }
 549     if (cpu_is_stopped(cpu)) {
 550         return false;
 551     }
 552     return true;
 553 }
 554
 555 static void cpu_handle_guest_debug(CPUState *cpu)
 556 {
 557     gdb_set_stop_cpu(cpu);
 558     qemu_system_debug_request();
 559     cpu->stopped = true;
 560 }
 561
 562 static void cpu_signal(int sig)
 563 {
 564     if (current_cpu) {
 565         cpu_exit(current_cpu);
 566     }
 567     exit_request = 1;
 568 }
 569
 570 #ifdef CONFIG_LINUX
 571 static void sigbus_reraise(void)
 572 {
 573     sigset_t set;
 574     struct sigaction action;
 575
 576     memset(&action, 0, sizeof(action));
 577     action.sa_handler = SIG_DFL;
 578     if (!sigaction(SIGBUS, &action, NULL)) {
 579         raise(SIGBUS);
 580         sigemptyset(&set);
 581         sigaddset(&set, SIGBUS);
 582         sigprocmask(SIG_UNBLOCK, &set, NULL);
 583     }
 584     perror("Failed to re-raise SIGBUS!\n");
 585     abort();
 586 }
 587
 588 static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo,
 589                            void *ctx)
 590 {
 591     if (kvm_on_sigbus(siginfo->ssi_code,
 592                       (void *)(intptr_t)siginfo->ssi_addr)) {
 593         sigbus_reraise();
 594     }
 595 }
 596
 597 static void qemu_init_sigbus(void)
 598 {
 599     struct sigaction action;
 600
 601     memset(&action, 0, sizeof(action));
 602     action.sa_flags = SA_SIGINFO;
 603     action.sa_sigaction = (void (*)(int, siginfo_t*, void*))sigbus_handler;
 604     sigaction(SIGBUS, &action, NULL);
 605
 606     prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, 0, 0);
 607 }
 608
 609 static void qemu_kvm_eat_signals(CPUState *cpu)
 610 {
 611     struct timespec ts = { 0, 0 };
 612     siginfo_t siginfo;
 613     sigset_t waitset;
 614     sigset_t chkset;
 615     int r;
 616
 617     sigemptyset(&waitset);
 618     sigaddset(&waitset, SIG_IPI);
 619     sigaddset(&waitset, SIGBUS);
 620
 621     do {
 622         r = sigtimedwait(&waitset, &siginfo, &ts);
 623         if (r == -1 && !(errno == EAGAIN || errno == EINTR)) {
 624             perror("sigtimedwait");
 625             exit(1);
 626         }
 627
 628         switch (r) {
 629         case SIGBUS:
 630             if (kvm_on_sigbus_vcpu(cpu, siginfo.si_code, siginfo.si_addr)) {
 631                 sigbus_reraise();
 632             }
 633             break;
 634         default:
 635             break;
 636         }
 637
 638         r = sigpending(&chkset);
 639         if (r == -1) {
 640             perror("sigpending");
 641             exit(1);
 642         }
 643     } while (sigismember(&chkset, SIG_IPI) || sigismember(&chkset, SIGBUS));
 644 }
 645
 646 #else /* !CONFIG_LINUX */
 647
 648 static void qemu_init_sigbus(void)
 649 {
 650 }
 651
 652 static void qemu_kvm_eat_signals(CPUState *cpu)
 653 {
 654 }
 655 #endif /* !CONFIG_LINUX */
 656
 657 #ifndef _WIN32
 658 static void dummy_signal(int sig)
 659 {
 660 }
 661
 662 static void qemu_kvm_init_cpu_signals(CPUState *cpu)
 663 {
 664     int r;
 665     sigset_t set;
 666     struct sigaction sigact;
 667
 668     memset(&sigact, 0, sizeof(sigact));
 669     sigact.sa_handler = dummy_signal;
 670     sigaction(SIG_IPI, &sigact, NULL);
 671
 672     pthread_sigmask(SIG_BLOCK, NULL, &set);
 673     sigdelset(&set, SIG_IPI);
 674     sigdelset(&set, SIGBUS);
 675     r = kvm_set_signal_mask(cpu, &set);
 676     if (r) {
 677         fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));
 678         exit(1);
 679     }
 680 }
 681
 682 static void qemu_tcg_init_cpu_signals(void)
 683 {
 684     sigset_t set;
 685     struct sigaction sigact;
 686
 687     memset(&sigact, 0, sizeof(sigact));
 688     sigact.sa_handler = cpu_signal;
 689     sigaction(SIG_IPI, &sigact, NULL);
 690
 691     sigemptyset(&set);
 692     sigaddset(&set, SIG_IPI);
 693     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
 694 }
 695
 696 #else /* _WIN32 */
 697 static void qemu_kvm_init_cpu_signals(CPUState *cpu)
 698 {
 699     abort();
 700 }
 701
 702 static void qemu_tcg_init_cpu_signals(void)
 703 {
 704 }
 705 #endif /* _WIN32 */
 706
 707 static QemuMutex qemu_global_mutex;
 708 static QemuCond qemu_io_proceeded_cond;
 709 static bool iothread_requesting_mutex;
 710
 711 static QemuThread io_thread;
 712
 713 static QemuThread *tcg_cpu_thread;
 714 static QemuCond *tcg_halt_cond;
 715
 716 /* cpu creation */
 717 static QemuCond qemu_cpu_cond;
 718 /* system init */
 719 static QemuCond qemu_pause_cond;
 720 static QemuCond qemu_work_cond;
 721
 722 void qemu_init_cpu_loop(void)
 723 {
 724     qemu_init_sigbus();
 725     qemu_cond_init(&qemu_cpu_cond);
 726     qemu_cond_init(&qemu_pause_cond);
 727     qemu_cond_init(&qemu_work_cond);
 728     qemu_cond_init(&qemu_io_proceeded_cond);
 729     qemu_mutex_init(&qemu_global_mutex);
 730
 731     qemu_thread_get_self(&io_thread);
 732 }
 733
 734 void run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data)
 735 {
 736     struct qemu_work_item wi;
 737
 738     if (qemu_cpu_is_self(cpu)) {
 739         func(data);
 740         return;
 741     }
 742
 743     wi.func = func;
 744     wi.data = data;
 745     wi.free = false;
 746     if (cpu->queued_work_first == NULL) {
 747         cpu->queued_work_first = &wi;
 748     } else {
 749         cpu->queued_work_last->next = &wi;
 750     }
 751     cpu->queued_work_last = &wi;
 752     wi.next = NULL;
 753     wi.done = false;
 754
 755     qemu_cpu_kick(cpu);
 756     while (!wi.done) {
 757         CPUState *self_cpu = current_cpu;
 758
 759         qemu_cond_wait(&qemu_work_cond, &qemu_global_mutex);
 760         current_cpu = self_cpu;
 761     }
 762 }
 763
 764 void async_run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data)
 765 {
 766     struct qemu_work_item *wi;
 767
 768     if (qemu_cpu_is_self(cpu)) {
 769         func(data);
 770         return;
 771     }
 772
 773     wi = g_malloc0(sizeof(struct qemu_work_item));
 774     wi->func = func;
 775     wi->data = data;
 776     wi->free = true;
 777     if (cpu->queued_work_first == NULL) {
 778         cpu->queued_work_first = wi;
 779     } else {
 780         cpu->queued_work_last->next = wi;
 781     }
 782     cpu->queued_work_last = wi;
 783     wi->next = NULL;
 784     wi->done = false;
 785
 786     qemu_cpu_kick(cpu);
 787 }
 788
 789 static void flush_queued_work(CPUState *cpu)
 790 {
 791     struct qemu_work_item *wi;
 792
 793     if (cpu->queued_work_first == NULL) {
 794         return;
 795     }
 796
 797     while ((wi = cpu->queued_work_first)) {
 798         cpu->queued_work_first = wi->next;
 799         wi->func(wi->data);
 800         wi->done = true;
 801         if (wi->free) {
 802             g_free(wi);
 803         }
 804     }
 805     cpu->queued_work_last = NULL;
 806     qemu_cond_broadcast(&qemu_work_cond);
 807 }
 808
 809 static void qemu_wait_io_event_common(CPUState *cpu)
 810 {
 811     if (cpu->stop) {
 812         cpu->stop = false;
 813         cpu->stopped = true;
 814         qemu_cond_signal(&qemu_pause_cond);
 815     }
 816     flush_queued_work(cpu);
 817     cpu->thread_kicked = false;
 818 }
 819
 820 static void qemu_tcg_wait_io_event(void)
 821 {
 822     CPUState *cpu;
 823
 824     while (all_cpu_threads_idle()) {
 825        /* Start accounting real time to the virtual clock if the CPUs
 826           are idle.  */
 827         qemu_clock_warp(QEMU_CLOCK_VIRTUAL);
 828         qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
 829     }
 830
 831     while (iothread_requesting_mutex) {
 832         qemu_cond_wait(&qemu_io_proceeded_cond, &qemu_global_mutex);
 833     }
 834
 835     CPU_FOREACH(cpu) {
 836         qemu_wait_io_event_common(cpu);
 837     }
 838 }
 839
 840 static void qemu_kvm_wait_io_event(CPUState *cpu)
 841 {
 842     while (cpu_thread_is_idle(cpu)) {
 843         qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
 844     }
 845
 846     qemu_kvm_eat_signals(cpu);
 847     qemu_wait_io_event_common(cpu);
 848 }
 849
 850 static void *qemu_kvm_cpu_thread_fn(void *arg)
 851 {
 852     CPUState *cpu = arg;
 853     int r;
 854
 855     qemu_mutex_lock(&qemu_global_mutex);
 856     qemu_thread_get_self(cpu->thread);
 857     cpu->thread_id = qemu_get_thread_id();
 858     current_cpu = cpu;
 859
 860     r = kvm_init_vcpu(cpu);
 861     if (r < 0) {
 862         fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r));
 863         exit(1);
 864     }
 865
 866     qemu_kvm_init_cpu_signals(cpu);
 867
 868     /* signal CPU creation */
 869     cpu->created = true;
 870     qemu_cond_signal(&qemu_cpu_cond);
 871
 872     while (1) {
 873         if (cpu_can_run(cpu)) {
 874             r = kvm_cpu_exec(cpu);
 875             if (r == EXCP_DEBUG) {
 876                 cpu_handle_guest_debug(cpu);
 877             }
 878         }
 879         qemu_kvm_wait_io_event(cpu);
 880     }
 881
 882     return NULL;
 883 }
 884
 885 static void *qemu_dummy_cpu_thread_fn(void *arg)
 886 {
 887 #ifdef _WIN32
 888     fprintf(stderr, "qtest is not supported under Windows\n");
 889     exit(1);
 890 #else
 891     CPUState *cpu = arg;
 892     sigset_t waitset;
 893     int r;
 894
 895     qemu_mutex_lock_iothread();
 896     qemu_thread_get_self(cpu->thread);
 897     cpu->thread_id = qemu_get_thread_id();
 898
 899     sigemptyset(&waitset);
 900     sigaddset(&waitset, SIG_IPI);
 901
 902     /* signal CPU creation */
 903     cpu->created = true;
 904     qemu_cond_signal(&qemu_cpu_cond);
 905
 906     current_cpu = cpu;
 907     while (1) {
 908         current_cpu = NULL;
 909         qemu_mutex_unlock_iothread();
 910         do {
 911             int sig;
 912             r = sigwait(&waitset, &sig);
 913         } while (r == -1 && (errno == EAGAIN || errno == EINTR));
 914         if (r == -1) {
 915             perror("sigwait");
 916             exit(1);
 917         }
 918         qemu_mutex_lock_iothread();
 919         current_cpu = cpu;
 920         qemu_wait_io_event_common(cpu);
 921     }
 922
 923     return NULL;
 924 #endif
 925 }
 926
 927 static void tcg_exec_all(void);
 928
 929 static void *qemu_tcg_cpu_thread_fn(void *arg)
 930 {
 931     CPUState *cpu = arg;
 932
 933     qemu_tcg_init_cpu_signals();
 934     qemu_thread_get_self(cpu->thread);
 935
 936     qemu_mutex_lock(&qemu_global_mutex);
 937     CPU_FOREACH(cpu) {
 938         cpu->thread_id = qemu_get_thread_id();
 939         cpu->created = true;
 940     }
 941     qemu_cond_signal(&qemu_cpu_cond);
 942
 943     /* wait for initial kick-off after machine start */
 944     while (QTAILQ_FIRST(&cpus)->stopped) {
 945         qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
 946
 947         /* process any pending work */
 948         CPU_FOREACH(cpu) {
 949             qemu_wait_io_event_common(cpu);
 950         }
 951     }
 952
 953     while (1) {
 954         tcg_exec_all();
 955
 956         if (use_icount) {
 957             int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
 958
 959             if (deadline == 0) {
 960                 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
 961             }
 962         }
 963         qemu_tcg_wait_io_event();
 964     }
 965
 966     return NULL;
 967 }
 968
 969 static void qemu_cpu_kick_thread(CPUState *cpu)
 970 {
 971 #ifndef _WIN32
 972     int err;
 973
 974     err = pthread_kill(cpu->thread->thread, SIG_IPI);
 975     if (err) {
 976         fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
 977         exit(1);
 978     }
 979 /* The cpu thread cannot catch it reliably when shutdown the guest on Mac.
 980  * We can double check it and resend it
 981  */
 982 #ifdef CONFIG_DARWIN
 983     if (!exit_request)
 984         cpu_signal(0);
 985 #endif
 986 #else /* _WIN32 */
 987     if (!qemu_cpu_is_self(cpu)) {
 988         CONTEXT tcgContext;
 989
 990         if (SuspendThread(cpu->hThread) == (DWORD)-1) {
 991             fprintf(stderr, "qemu:%s: GetLastError:%lu\n", __func__,
 992                     GetLastError());
 993             exit(1);
 994         }
 995
 996         /* On multi-core systems, we are not sure that the thread is actually
 997          * suspended until we can get the context.
 998          */
 999         tcgContext.ContextFlags = CONTEXT_CONTROL;
1000         while (GetThreadContext(cpu->hThread, &tcgContext) != 0) {
1001             continue;
1002         }
1003
1004         cpu_signal(0);
1005
1006         if (ResumeThread(cpu->hThread) == (DWORD)-1) {
1007             fprintf(stderr, "qemu:%s: GetLastError:%lu\n", __func__,
1008                     GetLastError());
1009             exit(1);
1010         }
1011     }
1012 #endif
1013 }
1014
1015 void qemu_cpu_kick(CPUState *cpu)
1016 {
1017     qemu_cond_broadcast(cpu->halt_cond);
1018     if (!tcg_enabled() && !cpu->thread_kicked) {
1019         qemu_cpu_kick_thread(cpu);
1020         cpu->thread_kicked = true;
1021     }
1022 }
1023
1024 void qemu_cpu_kick_self(void)
1025 {
1026 #ifndef _WIN32
1027     assert(current_cpu);
1028
1029     if (!current_cpu->thread_kicked) {
1030         qemu_cpu_kick_thread(current_cpu);
1031         current_cpu->thread_kicked = true;
1032     }
1033 #else
1034     abort();
1035 #endif
1036 }
1037
1038 bool qemu_cpu_is_self(CPUState *cpu)
1039 {
1040     return qemu_thread_is_self(cpu->thread);
1041 }
1042
1043 static bool qemu_in_vcpu_thread(void)
1044 {
1045     return current_cpu && qemu_cpu_is_self(current_cpu);
1046 }
1047
1048 void qemu_mutex_lock_iothread(void)
1049 {
1050     if (!tcg_enabled()) {
1051         qemu_mutex_lock(&qemu_global_mutex);
1052     } else {
1053         iothread_requesting_mutex = true;
1054         if (qemu_mutex_trylock(&qemu_global_mutex)) {
1055             qemu_cpu_kick_thread(first_cpu);
1056             qemu_mutex_lock(&qemu_global_mutex);
1057         }
1058         iothread_requesting_mutex = false;
1059         qemu_cond_broadcast(&qemu_io_proceeded_cond);
1060     }
1061 }
1062
1063 void qemu_mutex_unlock_iothread(void)
1064 {
1065     qemu_mutex_unlock(&qemu_global_mutex);
1066 }
1067
1068 static int all_vcpus_paused(void)
1069 {
1070     CPUState *cpu;
1071
1072     CPU_FOREACH(cpu) {
1073         if (!cpu->stopped) {
1074             return 0;
1075         }
1076     }
1077
1078     return 1;
1079 }
1080
1081 void pause_all_vcpus(void)
1082 {
1083     CPUState *cpu;
1084
1085     qemu_clock_enable(QEMU_CLOCK_VIRTUAL, false);
1086     CPU_FOREACH(cpu) {
1087         cpu->stop = true;
1088         qemu_cpu_kick(cpu);
1089     }
1090
1091     if (qemu_in_vcpu_thread()) {
1092         cpu_stop_current();
1093         if (!kvm_enabled()) {
1094             CPU_FOREACH(cpu) {
1095                 cpu->stop = false;
1096                 cpu->stopped = true;
1097             }
1098             return;
1099         }
1100     }
1101
1102     while (!all_vcpus_paused()) {
1103         qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
1104         CPU_FOREACH(cpu) {
1105             qemu_cpu_kick(cpu);
1106         }
1107     }
1108 }
1109
1110 void cpu_resume(CPUState *cpu)
1111 {
1112     cpu->stop = false;
1113     cpu->stopped = false;
1114     qemu_cpu_kick(cpu);
1115 }
1116
1117 void resume_all_vcpus(void)
1118 {
1119     CPUState *cpu;
1120
1121     qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
1122     CPU_FOREACH(cpu) {
1123         cpu_resume(cpu);
1124     }
1125 }
1126
1127 /* For temporary buffers for forming a name */
1128 #define VCPU_THREAD_NAME_SIZE 16
1129
1130 static void qemu_tcg_init_vcpu(CPUState *cpu)
1131 {
1132 #ifdef  CONFIG_HAX
1133         if (hax_enabled())
1134                 hax_init_vcpu(cpu->env_ptr);
1135 #endif
1136     char thread_name[VCPU_THREAD_NAME_SIZE];
1137
1138     tcg_cpu_address_space_init(cpu, cpu->as);
1139
1140     /* share a single thread for all cpus with TCG */
1141     if (!tcg_cpu_thread) {
1142         cpu->thread = g_malloc0(sizeof(QemuThread));
1143         cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1144         qemu_cond_init(cpu->halt_cond);
1145         tcg_halt_cond = cpu->halt_cond;
1146         snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/TCG",
1147                  cpu->cpu_index);
1148         qemu_thread_create(cpu->thread, thread_name, qemu_tcg_cpu_thread_fn,
1149                            cpu, QEMU_THREAD_JOINABLE);
1150 #ifdef _WIN32
1151         cpu->hThread = qemu_thread_get_handle(cpu->thread);
1152 #endif
1153         while (!cpu->created) {
1154             qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1155         }
1156         tcg_cpu_thread = cpu->thread;
1157     } else {
1158         cpu->thread = tcg_cpu_thread;
1159         cpu->halt_cond = tcg_halt_cond;
1160     }
1161 }
1162
1163 static void qemu_kvm_start_vcpu(CPUState *cpu)
1164 {
1165     char thread_name[VCPU_THREAD_NAME_SIZE];
1166
1167     cpu->thread = g_malloc0(sizeof(QemuThread));
1168     cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1169     qemu_cond_init(cpu->halt_cond);
1170     snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/KVM",
1171              cpu->cpu_index);
1172     qemu_thread_create(cpu->thread, thread_name, qemu_kvm_cpu_thread_fn,
1173                        cpu, QEMU_THREAD_JOINABLE);
1174     while (!cpu->created) {
1175         qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1176     }
1177 }
1178
1179 static void qemu_dummy_start_vcpu(CPUState *cpu)
1180 {
1181     char thread_name[VCPU_THREAD_NAME_SIZE];
1182
1183     cpu->thread = g_malloc0(sizeof(QemuThread));
1184     cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1185     qemu_cond_init(cpu->halt_cond);
1186     snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/DUMMY",
1187              cpu->cpu_index);
1188     qemu_thread_create(cpu->thread, thread_name, qemu_dummy_cpu_thread_fn, cpu,
1189                        QEMU_THREAD_JOINABLE);
1190     while (!cpu->created) {
1191         qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1192     }
1193 }
1194
1195 void qemu_init_vcpu(CPUState *cpu)
1196 {
1197     cpu->nr_cores = smp_cores;
1198     cpu->nr_threads = smp_threads;
1199     cpu->stopped = true;
1200     if (kvm_enabled()) {
1201         qemu_kvm_start_vcpu(cpu);
1202     } else if (tcg_enabled()) {
1203         qemu_tcg_init_vcpu(cpu);
1204     } else {
1205         qemu_dummy_start_vcpu(cpu);
1206     }
1207 }
1208
1209 void cpu_stop_current(void)
1210 {
1211     if (current_cpu) {
1212         current_cpu->stop = false;
1213         current_cpu->stopped = true;
1214         cpu_exit(current_cpu);
1215         qemu_cond_signal(&qemu_pause_cond);
1216     }
1217 }
1218
1219 int vm_stop(RunState state)
1220 {
1221     if (qemu_in_vcpu_thread()) {
1222         qemu_system_vmstop_request(state);
1223         /*
1224          * FIXME: should not return to device code in case
1225          * vm_stop() has been requested.
1226          */
1227         cpu_stop_current();
1228         return 0;
1229     }
1230
1231     return do_vm_stop(state);
1232 }
1233
1234 /* does a state transition even if the VM is already stopped,
1235    current state is forgotten forever */
1236 int vm_stop_force_state(RunState state)
1237 {
1238     if (runstate_is_running()) {
1239         return vm_stop(state);
1240     } else {
1241         runstate_set(state);
1242         /* Make sure to return an error if the flush in a previous vm_stop()
1243          * failed. */
1244         return bdrv_flush_all();
1245     }
1246 }
1247
1248 static int tcg_cpu_exec(CPUArchState *env)
1249 {
1250     CPUState *cpu = ENV_GET_CPU(env);
1251     int ret;
1252 #ifdef CONFIG_PROFILER
1253     int64_t ti;
1254 #endif
1255
1256 #ifdef CONFIG_PROFILER
1257     ti = profile_getclock();
1258 #endif
1259     if (use_icount) {
1260         int64_t count;
1261         int64_t deadline;
1262         int decr;
1263         qemu_icount -= (cpu->icount_decr.u16.low + cpu->icount_extra);
1264         cpu->icount_decr.u16.low = 0;
1265         cpu->icount_extra = 0;
1266         deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
1267
1268         /* Maintain prior (possibly buggy) behaviour where if no deadline
1269          * was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than
1270          * INT32_MAX nanoseconds ahead, we still use INT32_MAX
1271          * nanoseconds.
1272          */
1273         if ((deadline < 0) || (deadline > INT32_MAX)) {
1274             deadline = INT32_MAX;
1275         }
1276
1277         count = qemu_icount_round(deadline);
1278         qemu_icount += count;
1279         decr = (count > 0xffff) ? 0xffff : count;
1280         count -= decr;
1281         cpu->icount_decr.u16.low = decr;
1282         cpu->icount_extra = count;
1283     }
1284     ret = cpu_exec(env);
1285 #ifdef CONFIG_PROFILER
1286     qemu_time += profile_getclock() - ti;
1287 #endif
1288     if (use_icount) {
1289         /* Fold pending instructions back into the
1290            instruction counter, and clear the interrupt flag.  */
1291         qemu_icount -= (cpu->icount_decr.u16.low + cpu->icount_extra);
1292         cpu->icount_decr.u32 = 0;
1293         cpu->icount_extra = 0;
1294     }
1295     return ret;
1296 }
1297
1298 static void tcg_exec_all(void)
1299 {
1300     int r;
1301
1302     /* Account partial waits to QEMU_CLOCK_VIRTUAL.  */
1303     qemu_clock_warp(QEMU_CLOCK_VIRTUAL);
1304
1305     if (next_cpu == NULL) {
1306         next_cpu = first_cpu;
1307     }
1308     for (; next_cpu != NULL && !exit_request; next_cpu = CPU_NEXT(next_cpu)) {
1309         CPUState *cpu = next_cpu;
1310         CPUArchState *env = cpu->env_ptr;
1311
1312         qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
1313                           (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);
1314
1315         if (cpu_can_run(cpu)) {
1316             r = tcg_cpu_exec(env);
1317             if (r == EXCP_DEBUG) {
1318                 cpu_handle_guest_debug(cpu);
1319                 break;
1320             }
1321         } else if (cpu->stop || cpu->stopped) {
1322             break;
1323         }
1324     }
1325     exit_request = 0;
1326 }
1327
1328 void set_numa_modes(void)
1329 {
1330     CPUState *cpu;
1331     int i;
1332
1333     CPU_FOREACH(cpu) {
1334         for (i = 0; i < nb_numa_nodes; i++) {
1335             if (test_bit(cpu->cpu_index, node_cpumask[i])) {
1336                 cpu->numa_node = i;
1337             }
1338         }
1339     }
1340 }
1341
1342 void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
1343 {
1344     /* XXX: implement xxx_cpu_list for targets that still miss it */
1345 #if defined(cpu_list)
1346     cpu_list(f, cpu_fprintf);
1347 #endif
1348 }
1349
1350 CpuInfoList *qmp_query_cpus(Error **errp)
1351 {
1352     CpuInfoList *head = NULL, *cur_item = NULL;
1353     CPUState *cpu;
1354
1355     CPU_FOREACH(cpu) {
1356         CpuInfoList *info;
1357 #if defined(TARGET_I386)
1358         X86CPU *x86_cpu = X86_CPU(cpu);
1359         CPUX86State *env = &x86_cpu->env;
1360 #elif defined(TARGET_PPC)
1361         PowerPCCPU *ppc_cpu = POWERPC_CPU(cpu);
1362         CPUPPCState *env = &ppc_cpu->env;
1363 #elif defined(TARGET_SPARC)
1364         SPARCCPU *sparc_cpu = SPARC_CPU(cpu);
1365         CPUSPARCState *env = &sparc_cpu->env;
1366 #elif defined(TARGET_MIPS)
1367         MIPSCPU *mips_cpu = MIPS_CPU(cpu);
1368         CPUMIPSState *env = &mips_cpu->env;
1369 #endif
1370
1371         cpu_synchronize_state(cpu);
1372
1373         info = g_malloc0(sizeof(*info));
1374         info->value = g_malloc0(sizeof(*info->value));
1375         info->value->CPU = cpu->cpu_index;
1376         info->value->current = (cpu == first_cpu);
1377         info->value->halted = cpu->halted;
1378         info->value->thread_id = cpu->thread_id;
1379 #if defined(TARGET_I386)
1380         info->value->has_pc = true;
1381         info->value->pc = env->eip + env->segs[R_CS].base;
1382 #elif defined(TARGET_PPC)
1383         info->value->has_nip = true;
1384         info->value->nip = env->nip;
1385 #elif defined(TARGET_SPARC)
1386         info->value->has_pc = true;
1387         info->value->pc = env->pc;
1388         info->value->has_npc = true;
1389         info->value->npc = env->npc;
1390 #elif defined(TARGET_MIPS)
1391         info->value->has_PC = true;
1392         info->value->PC = env->active_tc.PC;
1393 #endif
1394
1395         /* XXX: waiting for the qapi to support GSList */
1396         if (!cur_item) {
1397             head = cur_item = info;
1398         } else {
1399             cur_item->next = info;
1400             cur_item = info;
1401         }
1402     }
1403
1404     return head;
1405 }
1406
1407 void qmp_memsave(int64_t addr, int64_t size, const char *filename,
1408                  bool has_cpu, int64_t cpu_index, Error **errp)
1409 {
1410     FILE *f;
1411     uint32_t l;
1412     CPUState *cpu;
1413     uint8_t buf[1024];
1414
1415     if (!has_cpu) {
1416         cpu_index = 0;
1417     }
1418
1419     cpu = qemu_get_cpu(cpu_index);
1420     if (cpu == NULL) {
1421         error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
1422                   "a CPU number");
1423         return;
1424     }
1425
1426     f = fopen(filename, "wb");
1427     if (!f) {
1428         error_setg_file_open(errp, errno, filename);
1429         return;
1430     }
1431
1432     while (size != 0) {
1433         l = sizeof(buf);
1434         if (l > size)
1435             l = size;
1436         if (cpu_memory_rw_debug(cpu, addr, buf, l, 0) != 0) {
1437             error_setg(errp, "Invalid addr 0x%016" PRIx64 "specified", addr);
1438             goto exit;
1439         }
1440         if (fwrite(buf, 1, l, f) != l) {
1441             error_set(errp, QERR_IO_ERROR);
1442             goto exit;
1443         }
1444         addr += l;
1445         size -= l;
1446     }
1447
1448 exit:
1449     fclose(f);
1450 }
1451
1452 void qmp_pmemsave(int64_t addr, int64_t size, const char *filename,
1453                   Error **errp)
1454 {
1455     FILE *f;
1456     uint32_t l;
1457     uint8_t buf[1024];
1458
1459     f = fopen(filename, "wb");
1460     if (!f) {
1461         error_setg_file_open(errp, errno, filename);
1462         return;
1463     }
1464
1465     while (size != 0) {
1466         l = sizeof(buf);
1467         if (l > size)
1468             l = size;
1469         cpu_physical_memory_rw(addr, buf, l, 0);
1470         if (fwrite(buf, 1, l, f) != l) {
1471             error_set(errp, QERR_IO_ERROR);
1472             goto exit;
1473         }
1474         addr += l;
1475         size -= l;
1476     }
1477
1478 exit:
1479     fclose(f);
1480 }
1481
1482 void qmp_inject_nmi(Error **errp)
1483 {
1484 #if defined(TARGET_I386)
1485     CPUState *cs;
1486
1487     CPU_FOREACH(cs) {
1488         X86CPU *cpu = X86_CPU(cs);
1489
1490         if (!cpu->apic_state) {
1491             cpu_interrupt(cs, CPU_INTERRUPT_NMI);
1492         } else {
1493             apic_deliver_nmi(cpu->apic_state);
1494         }
1495     }
1496 #elif defined(TARGET_S390X)
1497     CPUState *cs;
1498     S390CPU *cpu;
1499
1500     CPU_FOREACH(cs) {
1501         cpu = S390_CPU(cs);
1502         if (cpu->env.cpu_num == monitor_get_cpu_index()) {
1503             if (s390_cpu_restart(S390_CPU(cs)) == -1) {
1504                 error_set(errp, QERR_UNSUPPORTED);
1505                 return;
1506             }
1507             break;
1508         }
1509     }
1510 #else
1511     error_set(errp, QERR_UNSUPPORTED);
1512 #endif
1513 }