cpus.c 27.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
/*
 * QEMU System Emulator
 *
 * Copyright (c) 2003-2008 Fabrice Bellard
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

/* Needed early for CONFIG_BSD etc. */
#include "config-host.h"

#include "monitor.h"
#include "sysemu.h"
#include "gdbstub.h"
#include "dma.h"
#include "kvm.h"

P
Paolo Bonzini 已提交
34
#include "qemu-thread.h"
35
#include "cpus.h"
P
Paolo Bonzini 已提交
36
#include "main-loop.h"
J
Jan Kiszka 已提交
37 38

#ifndef _WIN32
M
Marcelo Tosatti 已提交
39
#include "compatfd.h"
J
Jan Kiszka 已提交
40
#endif
41

42 43 44 45
#ifdef CONFIG_LINUX

#include <sys/prctl.h>

M
Marcelo Tosatti 已提交
46 47 48 49
#ifndef PR_MCE_KILL
#define PR_MCE_KILL 33
#endif

50 51 52 53 54 55 56 57 58 59
#ifndef PR_MCE_KILL_SET
#define PR_MCE_KILL_SET 1
#endif

#ifndef PR_MCE_KILL_EARLY
#define PR_MCE_KILL_EARLY 1
#endif

#endif /* CONFIG_LINUX */

60 61
static CPUState *next_cpu;

P
Paolo Bonzini 已提交
62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
/***********************************************************/
/* guest cycle counter */

/* Conversion factor from emulated instructions to virtual clock ticks.  */
static int icount_time_shift;
/* Arbitrarily pick 1MIPS as the minimum allowable speed.  */
#define MAX_ICOUNT_SHIFT 10
/* Compensate for varying guest execution speed.  */
static int64_t qemu_icount_bias;
static QEMUTimer *icount_rt_timer;
static QEMUTimer *icount_vm_timer;
static QEMUTimer *icount_warp_timer;
static int64_t vm_clock_warp_start;
static int64_t qemu_icount;

typedef struct TimersState {
    int64_t cpu_ticks_prev;
    int64_t cpu_ticks_offset;
    int64_t cpu_clock_offset;
    int32_t cpu_ticks_enabled;
    int64_t dummy;
} TimersState;

TimersState timers_state;

/* Return the virtual CPU time, based on the instruction counter.  */
int64_t cpu_get_icount(void)
{
    int64_t icount;
    CPUState *env = cpu_single_env;;

    icount = qemu_icount;
    if (env) {
        if (!can_do_io(env)) {
            fprintf(stderr, "Bad clock read\n");
        }
        icount -= (env->icount_decr.u16.low + env->icount_extra);
    }
    return qemu_icount_bias + (icount << icount_time_shift);
}

/* return the host CPU cycle counter and handle stop/restart */
int64_t cpu_get_ticks(void)
{
    if (use_icount) {
        return cpu_get_icount();
    }
    if (!timers_state.cpu_ticks_enabled) {
        return timers_state.cpu_ticks_offset;
    } else {
        int64_t ticks;
        ticks = cpu_get_real_ticks();
        if (timers_state.cpu_ticks_prev > ticks) {
            /* Note: non increasing ticks may happen if the host uses
               software suspend */
            timers_state.cpu_ticks_offset += timers_state.cpu_ticks_prev - ticks;
        }
        timers_state.cpu_ticks_prev = ticks;
        return ticks + timers_state.cpu_ticks_offset;
    }
}

/* return the host CPU monotonic timer and handle stop/restart */
int64_t cpu_get_clock(void)
{
    int64_t ti;
    if (!timers_state.cpu_ticks_enabled) {
        return timers_state.cpu_clock_offset;
    } else {
        ti = get_clock();
        return ti + timers_state.cpu_clock_offset;
    }
}

/* enable cpu_get_ticks() */
void cpu_enable_ticks(void)
{
    if (!timers_state.cpu_ticks_enabled) {
        timers_state.cpu_ticks_offset -= cpu_get_real_ticks();
        timers_state.cpu_clock_offset -= get_clock();
        timers_state.cpu_ticks_enabled = 1;
    }
}

/* disable cpu_get_ticks() : the clock is stopped. You must not call
   cpu_get_ticks() after that.  */
void cpu_disable_ticks(void)
{
    if (timers_state.cpu_ticks_enabled) {
        timers_state.cpu_ticks_offset = cpu_get_ticks();
        timers_state.cpu_clock_offset = cpu_get_clock();
        timers_state.cpu_ticks_enabled = 0;
    }
}

/* Correlation between real and virtual time is always going to be
   fairly approximate, so ignore small variation.
   When the guest is idle real and virtual time will be aligned in
   the IO wait loop.  */
#define ICOUNT_WOBBLE (get_ticks_per_sec() / 10)

static void icount_adjust(void)
{
    int64_t cur_time;
    int64_t cur_icount;
    int64_t delta;
    static int64_t last_delta;
    /* If the VM is not running, then do nothing.  */
    if (!runstate_is_running()) {
        return;
    }
    cur_time = cpu_get_clock();
    cur_icount = qemu_get_clock_ns(vm_clock);
    delta = cur_icount - cur_time;
    /* FIXME: This is a very crude algorithm, somewhat prone to oscillation.  */
    if (delta > 0
        && last_delta + ICOUNT_WOBBLE < delta * 2
        && icount_time_shift > 0) {
        /* The guest is getting too far ahead.  Slow time down.  */
        icount_time_shift--;
    }
    if (delta < 0
        && last_delta - ICOUNT_WOBBLE > delta * 2
        && icount_time_shift < MAX_ICOUNT_SHIFT) {
        /* The guest is getting too far behind.  Speed time up.  */
        icount_time_shift++;
    }
    last_delta = delta;
    qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
}

static void icount_adjust_rt(void *opaque)
{
    qemu_mod_timer(icount_rt_timer,
                   qemu_get_clock_ms(rt_clock) + 1000);
    icount_adjust();
}

static void icount_adjust_vm(void *opaque)
{
    qemu_mod_timer(icount_vm_timer,
                   qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 10);
    icount_adjust();
}

static int64_t qemu_icount_round(int64_t count)
{
    return (count + (1 << icount_time_shift) - 1) >> icount_time_shift;
}

static void icount_warp_rt(void *opaque)
{
    if (vm_clock_warp_start == -1) {
        return;
    }

    if (runstate_is_running()) {
        int64_t clock = qemu_get_clock_ns(rt_clock);
        int64_t warp_delta = clock - vm_clock_warp_start;
        if (use_icount == 1) {
            qemu_icount_bias += warp_delta;
        } else {
            /*
             * In adaptive mode, do not let the vm_clock run too
             * far ahead of real time.
             */
            int64_t cur_time = cpu_get_clock();
            int64_t cur_icount = qemu_get_clock_ns(vm_clock);
            int64_t delta = cur_time - cur_icount;
            qemu_icount_bias += MIN(warp_delta, delta);
        }
        if (qemu_clock_expired(vm_clock)) {
            qemu_notify_event();
        }
    }
    vm_clock_warp_start = -1;
}

void qemu_clock_warp(QEMUClock *clock)
{
    int64_t deadline;

    /*
     * There are too many global variables to make the "warp" behavior
     * applicable to other clocks.  But a clock argument removes the
     * need for if statements all over the place.
     */
    if (clock != vm_clock || !use_icount) {
        return;
    }

    /*
     * If the CPUs have been sleeping, advance the vm_clock timer now.  This
     * ensures that the deadline for the timer is computed correctly below.
     * This also makes sure that the insn counter is synchronized before the
     * CPU starts running, in case the CPU is woken by an event other than
     * the earliest vm_clock timer.
     */
    icount_warp_rt(NULL);
    if (!all_cpu_threads_idle() || !qemu_clock_has_timers(vm_clock)) {
        qemu_del_timer(icount_warp_timer);
        return;
    }

    vm_clock_warp_start = qemu_get_clock_ns(rt_clock);
    deadline = qemu_clock_deadline(vm_clock);
    if (deadline > 0) {
        /*
         * Ensure the vm_clock proceeds even when the virtual CPU goes to
         * sleep.  Otherwise, the CPU might be waiting for a future timer
         * interrupt to wake it up, but the interrupt never comes because
         * the vCPU isn't running any insns and thus doesn't advance the
         * vm_clock.
         *
         * An extreme solution for this problem would be to never let VCPUs
         * sleep in icount mode if there is a pending vm_clock timer; rather
         * time could just advance to the next vm_clock event.  Instead, we
         * do stop VCPUs and only advance vm_clock after some "real" time,
         * (related to the time left until the next event) has passed.  This
         * rt_clock timer will do this.  This avoids that the warps are too
         * visible externally---for example, you will not be sending network
         * packets continously instead of every 100ms.
         */
        qemu_mod_timer(icount_warp_timer, vm_clock_warp_start + deadline);
    } else {
        qemu_notify_event();
    }
}

static const VMStateDescription vmstate_timers = {
    .name = "timer",
    .version_id = 2,
    .minimum_version_id = 1,
    .minimum_version_id_old = 1,
    .fields      = (VMStateField[]) {
        VMSTATE_INT64(cpu_ticks_offset, TimersState),
        VMSTATE_INT64(dummy, TimersState),
        VMSTATE_INT64_V(cpu_clock_offset, TimersState, 2),
        VMSTATE_END_OF_LIST()
    }
};

void configure_icount(const char *option)
{
    vmstate_register(NULL, 0, &vmstate_timers, &timers_state);
    if (!option) {
        return;
    }

    icount_warp_timer = qemu_new_timer_ns(rt_clock, icount_warp_rt, NULL);
    if (strcmp(option, "auto") != 0) {
        icount_time_shift = strtol(option, NULL, 0);
        use_icount = 1;
        return;
    }

    use_icount = 2;

    /* 125MIPS seems a reasonable initial guess at the guest speed.
       It will be corrected fairly quickly anyway.  */
    icount_time_shift = 3;

    /* Have both realtime and virtual time triggers for speed adjustment.
       The realtime trigger catches emulated time passing too slowly,
       the virtual time trigger catches emulated time passing too fast.
       Realtime triggers occur even when idle, so use them less frequently
       than VM triggers.  */
    icount_rt_timer = qemu_new_timer_ms(rt_clock, icount_adjust_rt, NULL);
    qemu_mod_timer(icount_rt_timer,
                   qemu_get_clock_ms(rt_clock) + 1000);
    icount_vm_timer = qemu_new_timer_ns(vm_clock, icount_adjust_vm, NULL);
    qemu_mod_timer(icount_vm_timer,
                   qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 10);
}

337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
/***********************************************************/
void hw_error(const char *fmt, ...)
{
    va_list ap;
    CPUState *env;

    va_start(ap, fmt);
    fprintf(stderr, "qemu: hardware error: ");
    vfprintf(stderr, fmt, ap);
    fprintf(stderr, "\n");
    for(env = first_cpu; env != NULL; env = env->next_cpu) {
        fprintf(stderr, "CPU #%d:\n", env->cpu_index);
#ifdef TARGET_I386
        cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
#else
        cpu_dump_state(env, stderr, fprintf, 0);
#endif
    }
    va_end(ap);
    abort();
}

void cpu_synchronize_all_states(void)
{
    CPUState *cpu;

    for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
        cpu_synchronize_state(cpu);
    }
}

void cpu_synchronize_all_post_reset(void)
{
    CPUState *cpu;

    for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
        cpu_synchronize_post_reset(cpu);
    }
}

void cpu_synchronize_all_post_init(void)
{
    CPUState *cpu;

    for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
        cpu_synchronize_post_init(cpu);
    }
}

M
Marcelo Tosatti 已提交
386 387
int cpu_is_stopped(CPUState *env)
{
388
    return !runstate_is_running() || env->stopped;
M
Marcelo Tosatti 已提交
389 390
}

391
static void do_vm_stop(RunState state)
392
{
393
    if (runstate_is_running()) {
394 395
        cpu_disable_ticks();
        pause_all_vcpus();
396
        runstate_set(state);
397
        vm_state_notify(0, state);
398 399
        qemu_aio_flush();
        bdrv_flush_all();
400 401 402 403 404 405
        monitor_protocol_event(QEVENT_STOP, NULL);
    }
}

static int cpu_can_run(CPUState *env)
{
406
    if (env->stop) {
407
        return 0;
408
    }
409
    if (env->stopped || !runstate_is_running()) {
410
        return 0;
411
    }
412 413 414
    return 1;
}

415
static bool cpu_thread_is_idle(CPUState *env)
416
{
417 418 419
    if (env->stop || env->queued_work_first) {
        return false;
    }
420
    if (env->stopped || !runstate_is_running()) {
421 422
        return true;
    }
423 424
    if (!env->halted || qemu_cpu_has_work(env) ||
        (kvm_enabled() && kvm_irqchip_in_kernel())) {
425 426 427
        return false;
    }
    return true;
428 429
}

430
bool all_cpu_threads_idle(void)
431 432 433
{
    CPUState *env;

434 435 436 437 438 439
    for (env = first_cpu; env != NULL; env = env->next_cpu) {
        if (!cpu_thread_is_idle(env)) {
            return false;
        }
    }
    return true;
440 441
}

442
static void cpu_handle_guest_debug(CPUState *env)
443
{
444
    gdb_set_stop_cpu(env);
445
    qemu_system_debug_request();
446
    env->stopped = 1;
447 448
}

449 450 451 452 453 454 455 456
static void cpu_signal(int sig)
{
    if (cpu_single_env) {
        cpu_exit(cpu_single_env);
    }
    exit_request = 1;
}

457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495
#ifdef CONFIG_LINUX
static void sigbus_reraise(void)
{
    sigset_t set;
    struct sigaction action;

    memset(&action, 0, sizeof(action));
    action.sa_handler = SIG_DFL;
    if (!sigaction(SIGBUS, &action, NULL)) {
        raise(SIGBUS);
        sigemptyset(&set);
        sigaddset(&set, SIGBUS);
        sigprocmask(SIG_UNBLOCK, &set, NULL);
    }
    perror("Failed to re-raise SIGBUS!\n");
    abort();
}

static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo,
                           void *ctx)
{
    if (kvm_on_sigbus(siginfo->ssi_code,
                      (void *)(intptr_t)siginfo->ssi_addr)) {
        sigbus_reraise();
    }
}

static void qemu_init_sigbus(void)
{
    struct sigaction action;

    memset(&action, 0, sizeof(action));
    action.sa_flags = SA_SIGINFO;
    action.sa_sigaction = (void (*)(int, siginfo_t*, void*))sigbus_handler;
    sigaction(SIGBUS, &action, NULL);

    prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, 0, 0);
}

496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532
static void qemu_kvm_eat_signals(CPUState *env)
{
    struct timespec ts = { 0, 0 };
    siginfo_t siginfo;
    sigset_t waitset;
    sigset_t chkset;
    int r;

    sigemptyset(&waitset);
    sigaddset(&waitset, SIG_IPI);
    sigaddset(&waitset, SIGBUS);

    do {
        r = sigtimedwait(&waitset, &siginfo, &ts);
        if (r == -1 && !(errno == EAGAIN || errno == EINTR)) {
            perror("sigtimedwait");
            exit(1);
        }

        switch (r) {
        case SIGBUS:
            if (kvm_on_sigbus_vcpu(env, siginfo.si_code, siginfo.si_addr)) {
                sigbus_reraise();
            }
            break;
        default:
            break;
        }

        r = sigpending(&chkset);
        if (r == -1) {
            perror("sigpending");
            exit(1);
        }
    } while (sigismember(&chkset, SIG_IPI) || sigismember(&chkset, SIGBUS));
}

533 534 535 536 537
#else /* !CONFIG_LINUX */

static void qemu_init_sigbus(void)
{
}
538 539 540 541

static void qemu_kvm_eat_signals(CPUState *env)
{
}
542 543
#endif /* !CONFIG_LINUX */

544
#ifndef _WIN32
545 546 547 548
static void dummy_signal(int sig)
{
}

549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
static void qemu_kvm_init_cpu_signals(CPUState *env)
{
    int r;
    sigset_t set;
    struct sigaction sigact;

    memset(&sigact, 0, sizeof(sigact));
    sigact.sa_handler = dummy_signal;
    sigaction(SIG_IPI, &sigact, NULL);

    pthread_sigmask(SIG_BLOCK, NULL, &set);
    sigdelset(&set, SIG_IPI);
    sigdelset(&set, SIGBUS);
    r = kvm_set_signal_mask(env, &set);
    if (r) {
        fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));
        exit(1);
    }

    sigdelset(&set, SIG_IPI);
    sigdelset(&set, SIGBUS);
    r = kvm_set_signal_mask(env, &set);
    if (r) {
        fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));
        exit(1);
    }
}

static void qemu_tcg_init_cpu_signals(void)
{
    sigset_t set;
    struct sigaction sigact;

    memset(&sigact, 0, sizeof(sigact));
    sigact.sa_handler = cpu_signal;
    sigaction(SIG_IPI, &sigact, NULL);

    sigemptyset(&set);
    sigaddset(&set, SIG_IPI);
    pthread_sigmask(SIG_UNBLOCK, &set, NULL);
}

591
#else /* _WIN32 */
592 593
static void qemu_kvm_init_cpu_signals(CPUState *env)
{
594 595
    abort();
}
596

597 598
static void qemu_tcg_init_cpu_signals(void)
{
599
}
600
#endif /* _WIN32 */
601

602
QemuMutex qemu_global_mutex;
603 604
static QemuCond qemu_io_proceeded_cond;
static bool iothread_requesting_mutex;
605 606 607 608 609 610 611 612 613 614

static QemuThread io_thread;

static QemuThread *tcg_cpu_thread;
static QemuCond *tcg_halt_cond;

/* cpu creation */
static QemuCond qemu_cpu_cond;
/* system init */
static QemuCond qemu_pause_cond;
M
Marcelo Tosatti 已提交
615
static QemuCond qemu_work_cond;
616

P
Paolo Bonzini 已提交
617
void qemu_init_cpu_loop(void)
618
{
619
    qemu_init_sigbus();
620 621 622
    qemu_cond_init(&qemu_cpu_cond);
    qemu_cond_init(&qemu_pause_cond);
    qemu_cond_init(&qemu_work_cond);
623
    qemu_cond_init(&qemu_io_proceeded_cond);
624 625
    qemu_mutex_init(&qemu_global_mutex);

J
Jan Kiszka 已提交
626
    qemu_thread_get_self(&io_thread);
627 628
}

M
Marcelo Tosatti 已提交
629 630 631 632
void run_on_cpu(CPUState *env, void (*func)(void *data), void *data)
{
    struct qemu_work_item wi;

J
Jan Kiszka 已提交
633
    if (qemu_cpu_is_self(env)) {
M
Marcelo Tosatti 已提交
634 635 636 637 638 639
        func(data);
        return;
    }

    wi.func = func;
    wi.data = data;
640
    if (!env->queued_work_first) {
M
Marcelo Tosatti 已提交
641
        env->queued_work_first = &wi;
642
    } else {
M
Marcelo Tosatti 已提交
643
        env->queued_work_last->next = &wi;
644
    }
M
Marcelo Tosatti 已提交
645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661
    env->queued_work_last = &wi;
    wi.next = NULL;
    wi.done = false;

    qemu_cpu_kick(env);
    while (!wi.done) {
        CPUState *self_env = cpu_single_env;

        qemu_cond_wait(&qemu_work_cond, &qemu_global_mutex);
        cpu_single_env = self_env;
    }
}

static void flush_queued_work(CPUState *env)
{
    struct qemu_work_item *wi;

662
    if (!env->queued_work_first) {
M
Marcelo Tosatti 已提交
663
        return;
664
    }
M
Marcelo Tosatti 已提交
665 666 667 668 669 670 671 672 673 674

    while ((wi = env->queued_work_first)) {
        env->queued_work_first = wi->next;
        wi->func(wi->data);
        wi->done = true;
    }
    env->queued_work_last = NULL;
    qemu_cond_broadcast(&qemu_work_cond);
}

675 676 677 678 679 680 681
static void qemu_wait_io_event_common(CPUState *env)
{
    if (env->stop) {
        env->stop = 0;
        env->stopped = 1;
        qemu_cond_signal(&qemu_pause_cond);
    }
M
Marcelo Tosatti 已提交
682
    flush_queued_work(env);
683
    env->thread_kicked = false;
684 685
}

686
static void qemu_tcg_wait_io_event(void)
687
{
688 689
    CPUState *env;

690
    while (all_cpu_threads_idle()) {
691 692 693
       /* Start accounting real time to the virtual clock if the CPUs
          are idle.  */
        qemu_clock_warp(vm_clock);
694
        qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
695
    }
696

697 698 699
    while (iothread_requesting_mutex) {
        qemu_cond_wait(&qemu_io_proceeded_cond, &qemu_global_mutex);
    }
700 701 702 703

    for (env = first_cpu; env != NULL; env = env->next_cpu) {
        qemu_wait_io_event_common(env);
    }
704 705 706 707
}

static void qemu_kvm_wait_io_event(CPUState *env)
{
708
    while (cpu_thread_is_idle(env)) {
709
        qemu_cond_wait(env->halt_cond, &qemu_global_mutex);
710
    }
711

J
Jan Kiszka 已提交
712
    qemu_kvm_eat_signals(env);
713 714 715
    qemu_wait_io_event_common(env);
}

716
static void *qemu_kvm_cpu_thread_fn(void *arg)
717 718
{
    CPUState *env = arg;
J
Jan Kiszka 已提交
719
    int r;
720

721
    qemu_mutex_lock(&qemu_global_mutex);
J
Jan Kiszka 已提交
722
    qemu_thread_get_self(env->thread);
J
Jan Kiszka 已提交
723
    env->thread_id = qemu_get_thread_id();
724

J
Jan Kiszka 已提交
725 726 727 728 729
    r = kvm_init_vcpu(env);
    if (r < 0) {
        fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r));
        exit(1);
    }
730

731
    qemu_kvm_init_cpu_signals(env);
732 733 734 735 736 737

    /* signal CPU creation */
    env->created = 1;
    qemu_cond_signal(&qemu_cpu_cond);

    while (1) {
738
        if (cpu_can_run(env)) {
739
            r = kvm_cpu_exec(env);
740
            if (r == EXCP_DEBUG) {
741
                cpu_handle_guest_debug(env);
742
            }
743
        }
744 745 746 747 748 749
        qemu_kvm_wait_io_event(env);
    }

    return NULL;
}

750
static void *qemu_tcg_cpu_thread_fn(void *arg)
751 752 753
{
    CPUState *env = arg;

754
    qemu_tcg_init_cpu_signals();
J
Jan Kiszka 已提交
755
    qemu_thread_get_self(env->thread);
756 757 758

    /* signal CPU creation */
    qemu_mutex_lock(&qemu_global_mutex);
759
    for (env = first_cpu; env != NULL; env = env->next_cpu) {
J
Jan Kiszka 已提交
760
        env->thread_id = qemu_get_thread_id();
761
        env->created = 1;
762
    }
763 764
    qemu_cond_signal(&qemu_cpu_cond);

765 766 767
    /* wait for initial kick-off after machine start */
    while (first_cpu->stopped) {
        qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
768
    }
769 770

    while (1) {
771
        cpu_exec_all();
P
Paolo Bonzini 已提交
772
        if (use_icount && qemu_clock_deadline(vm_clock) <= 0) {
773 774
            qemu_notify_event();
        }
775
        qemu_tcg_wait_io_event();
776 777 778 779 780
    }

    return NULL;
}

P
Paolo Bonzini 已提交
781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799
static void qemu_cpu_kick_thread(CPUState *env)
{
#ifndef _WIN32
    int err;

    err = pthread_kill(env->thread->thread, SIG_IPI);
    if (err) {
        fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
        exit(1);
    }
#else /* _WIN32 */
    if (!qemu_cpu_is_self(env)) {
        SuspendThread(env->thread->thread);
        cpu_signal(0);
        ResumeThread(env->thread->thread);
    }
#endif
}

800 801 802 803 804
void qemu_cpu_kick(void *_env)
{
    CPUState *env = _env;

    qemu_cond_broadcast(env->halt_cond);
J
Jan Kiszka 已提交
805
    if (kvm_enabled() && !env->thread_kicked) {
P
Paolo Bonzini 已提交
806
        qemu_cpu_kick_thread(env);
807 808
        env->thread_kicked = true;
    }
809 810
}

811
void qemu_cpu_kick_self(void)
812
{
813
#ifndef _WIN32
814
    assert(cpu_single_env);
815

816
    if (!cpu_single_env->thread_kicked) {
P
Paolo Bonzini 已提交
817
        qemu_cpu_kick_thread(cpu_single_env);
818
        cpu_single_env->thread_kicked = true;
819
    }
820 821 822
#else
    abort();
#endif
823 824
}

J
Jan Kiszka 已提交
825
int qemu_cpu_is_self(void *_env)
826 827
{
    CPUState *env = _env;
M
Marcelo Tosatti 已提交
828

J
Jan Kiszka 已提交
829
    return qemu_thread_is_self(env->thread);
830 831 832 833 834 835
}

void qemu_mutex_lock_iothread(void)
{
    if (kvm_enabled()) {
        qemu_mutex_lock(&qemu_global_mutex);
836
    } else {
837
        iothread_requesting_mutex = true;
838
        if (qemu_mutex_trylock(&qemu_global_mutex)) {
P
Paolo Bonzini 已提交
839
            qemu_cpu_kick_thread(first_cpu);
840 841
            qemu_mutex_lock(&qemu_global_mutex);
        }
842 843
        iothread_requesting_mutex = false;
        qemu_cond_broadcast(&qemu_io_proceeded_cond);
844
    }
845 846 847 848 849 850 851 852 853 854 855 856
}

void qemu_mutex_unlock_iothread(void)
{
    qemu_mutex_unlock(&qemu_global_mutex);
}

static int all_vcpus_paused(void)
{
    CPUState *penv = first_cpu;

    while (penv) {
857
        if (!penv->stopped) {
858
            return 0;
859
        }
860 861 862 863 864 865 866 867 868 869
        penv = (CPUState *)penv->next_cpu;
    }

    return 1;
}

void pause_all_vcpus(void)
{
    CPUState *penv = first_cpu;

870
    qemu_clock_enable(vm_clock, false);
871 872 873 874 875 876 877
    while (penv) {
        penv->stop = 1;
        qemu_cpu_kick(penv);
        penv = (CPUState *)penv->next_cpu;
    }

    while (!all_vcpus_paused()) {
878
        qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
879 880
        penv = first_cpu;
        while (penv) {
881
            qemu_cpu_kick(penv);
882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898
            penv = (CPUState *)penv->next_cpu;
        }
    }
}

void resume_all_vcpus(void)
{
    CPUState *penv = first_cpu;

    while (penv) {
        penv->stop = 0;
        penv->stopped = 0;
        qemu_cpu_kick(penv);
        penv = (CPUState *)penv->next_cpu;
    }
}

899
static void qemu_tcg_init_vcpu(void *_env)
900 901
{
    CPUState *env = _env;
902

903 904
    /* share a single thread for all cpus with TCG */
    if (!tcg_cpu_thread) {
905 906
        env->thread = g_malloc0(sizeof(QemuThread));
        env->halt_cond = g_malloc0(sizeof(QemuCond));
907
        qemu_cond_init(env->halt_cond);
908
        tcg_halt_cond = env->halt_cond;
909
        qemu_thread_create(env->thread, qemu_tcg_cpu_thread_fn, env);
910
        while (env->created == 0) {
911
            qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
912
        }
913 914 915 916 917 918 919
        tcg_cpu_thread = env->thread;
    } else {
        env->thread = tcg_cpu_thread;
        env->halt_cond = tcg_halt_cond;
    }
}

920
static void qemu_kvm_start_vcpu(CPUState *env)
921
{
922 923
    env->thread = g_malloc0(sizeof(QemuThread));
    env->halt_cond = g_malloc0(sizeof(QemuCond));
924
    qemu_cond_init(env->halt_cond);
925
    qemu_thread_create(env->thread, qemu_kvm_cpu_thread_fn, env);
926
    while (env->created == 0) {
927
        qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
928
    }
929 930 931 932 933 934 935 936
}

void qemu_init_vcpu(void *_env)
{
    CPUState *env = _env;

    env->nr_cores = smp_cores;
    env->nr_threads = smp_threads;
937
    env->stopped = 1;
938
    if (kvm_enabled()) {
939
        qemu_kvm_start_vcpu(env);
940
    } else {
941
        qemu_tcg_init_vcpu(env);
942
    }
943 944
}

945
void cpu_stop_current(void)
946
{
947
    if (cpu_single_env) {
948
        cpu_single_env->stop = 0;
949 950
        cpu_single_env->stopped = 1;
        cpu_exit(cpu_single_env);
951
        qemu_cond_signal(&qemu_pause_cond);
952
    }
953 954
}

955
void vm_stop(RunState state)
956
{
J
Jan Kiszka 已提交
957
    if (!qemu_thread_is_self(&io_thread)) {
958
        qemu_system_vmstop_request(state);
959 960 961 962
        /*
         * FIXME: should not return to device code in case
         * vm_stop() has been requested.
         */
963
        cpu_stop_current();
964 965
        return;
    }
966
    do_vm_stop(state);
967 968
}

969 970 971 972 973 974 975 976 977 978 979
/* does a state transition even if the VM is already stopped,
   current state is forgotten forever */
void vm_stop_force_state(RunState state)
{
    if (runstate_is_running()) {
        vm_stop(state);
    } else {
        runstate_set(state);
    }
}

980
static int tcg_cpu_exec(CPUState *env)
981 982 983 984 985 986 987 988 989 990 991 992 993 994 995
{
    int ret;
#ifdef CONFIG_PROFILER
    int64_t ti;
#endif

#ifdef CONFIG_PROFILER
    ti = profile_getclock();
#endif
    if (use_icount) {
        int64_t count;
        int decr;
        qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
        env->icount_decr.u16.low = 0;
        env->icount_extra = 0;
P
Paolo Bonzini 已提交
996
        count = qemu_icount_round(qemu_clock_deadline(vm_clock));
997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017
        qemu_icount += count;
        decr = (count > 0xffff) ? 0xffff : count;
        count -= decr;
        env->icount_decr.u16.low = decr;
        env->icount_extra = count;
    }
    ret = cpu_exec(env);
#ifdef CONFIG_PROFILER
    qemu_time += profile_getclock() - ti;
#endif
    if (use_icount) {
        /* Fold pending instructions back into the
           instruction counter, and clear the interrupt flag.  */
        qemu_icount -= (env->icount_decr.u16.low
                        + env->icount_extra);
        env->icount_decr.u32 = 0;
        env->icount_extra = 0;
    }
    return ret;
}

1018
bool cpu_exec_all(void)
1019
{
1020 1021
    int r;

1022 1023 1024
    /* Account partial waits to the vm_clock.  */
    qemu_clock_warp(vm_clock);

1025
    if (next_cpu == NULL) {
1026
        next_cpu = first_cpu;
1027
    }
J
Jan Kiszka 已提交
1028
    for (; next_cpu != NULL && !exit_request; next_cpu = next_cpu->next_cpu) {
1029
        CPUState *env = next_cpu;
1030 1031

        qemu_clock_enable(vm_clock,
1032
                          (env->singlestep_enabled & SSTEP_NOTIMER) == 0);
1033

1034
        if (cpu_can_run(env)) {
1035
            if (kvm_enabled()) {
1036
                r = kvm_cpu_exec(env);
1037
                qemu_kvm_eat_signals(env);
1038 1039
            } else {
                r = tcg_cpu_exec(env);
1040 1041
            }
            if (r == EXCP_DEBUG) {
1042
                cpu_handle_guest_debug(env);
1043 1044
                break;
            }
1045
        } else if (env->stop || env->stopped) {
1046 1047 1048
            break;
        }
    }
J
Jan Kiszka 已提交
1049
    exit_request = 0;
1050
    return !all_cpu_threads_idle();
1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
}

void set_numa_modes(void)
{
    CPUState *env;
    int i;

    for (env = first_cpu; env != NULL; env = env->next_cpu) {
        for (i = 0; i < nb_numa_nodes; i++) {
            if (node_cpumask[i] & (1 << env->cpu_index)) {
                env->numa_node = i;
            }
        }
    }
}

void set_cpu_log(const char *optarg)
{
    int mask;
    const CPULogItem *item;

    mask = cpu_str_to_log_mask(optarg);
    if (!mask) {
        printf("Log items (comma separated):\n");
        for (item = cpu_log_items; item->mask != 0; item++) {
            printf("%-10s %s\n", item->name, item->help);
        }
        exit(1);
    }
    cpu_set_log(mask);
}
B
Blue Swirl 已提交
1082

1083 1084 1085 1086 1087
void set_cpu_log_filename(const char *optarg)
{
    cpu_set_log_filename(optarg);
}

1088
void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
1089 1090 1091 1092 1093 1094 1095 1096
{
    /* XXX: implement xxx_cpu_list for targets that still miss it */
#if defined(cpu_list_id)
    cpu_list_id(f, cpu_fprintf, optarg);
#elif defined(cpu_list)
    cpu_list(f, cpu_fprintf); /* deprecated */
#endif
}