cpus.c

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