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