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