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