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