cpus.c 33.1 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
/*
 * 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"

28
#include "monitor/monitor.h"
29
#include "sysemu/sysemu.h"
30
#include "exec/gdbstub.h"
31 32
#include "sysemu/dma.h"
#include "sysemu/kvm.h"
L
Luiz Capitulino 已提交
33
#include "qmp-commands.h"
34

35
#include "qemu/thread.h"
36 37
#include "sysemu/cpus.h"
#include "sysemu/qtest.h"
38 39
#include "qemu/main-loop.h"
#include "qemu/bitmap.h"
J
Jan Kiszka 已提交
40 41

#ifndef _WIN32
42
#include "qemu/compatfd.h"
J
Jan Kiszka 已提交
43
#endif
44

45 46 47 48
#ifdef CONFIG_LINUX

#include <sys/prctl.h>

M
Marcelo Tosatti 已提交
49 50 51 52
#ifndef PR_MCE_KILL
#define PR_MCE_KILL 33
#endif

53 54 55 56 57 58 59 60 61 62
#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 */

63
static CPUArchState *next_cpu;
64

65 66
static bool cpu_thread_is_idle(CPUArchState *env)
{
A
Andreas Färber 已提交
67 68
    CPUState *cpu = ENV_GET_CPU(env);

69
    if (cpu->stop || cpu->queued_work_first) {
70 71
        return false;
    }
72
    if (cpu->stopped || !runstate_is_running()) {
73 74
        return true;
    }
75
    if (!env->halted || qemu_cpu_has_work(cpu) ||
76
        kvm_async_interrupts_enabled()) {
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
        return false;
    }
    return true;
}

static bool all_cpu_threads_idle(void)
{
    CPUArchState *env;

    for (env = first_cpu; env != NULL; env = env->next_cpu) {
        if (!cpu_thread_is_idle(env)) {
            return false;
        }
    }
    return true;
}

P
Paolo Bonzini 已提交
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
/***********************************************************/
/* 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;
123
    CPUArchState *env = cpu_single_env;
P
Paolo Bonzini 已提交
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

    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;
}

P
Paolo Bonzini 已提交
272 273 274 275 276 277 278 279 280 281 282 283 284 285
void qtest_clock_warp(int64_t dest)
{
    int64_t clock = qemu_get_clock_ns(vm_clock);
    assert(qtest_enabled());
    while (clock < dest) {
        int64_t deadline = qemu_clock_deadline(vm_clock);
        int64_t warp = MIN(dest - clock, deadline);
        qemu_icount_bias += warp;
        qemu_run_timers(vm_clock);
        clock = qemu_get_clock_ns(vm_clock);
    }
    qemu_notify_event();
}

P
Paolo Bonzini 已提交
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
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;
    }

P
Paolo Bonzini 已提交
312 313 314 315 316
    if (qtest_enabled()) {
        /* When testing, qtest commands advance icount.  */
	return;
    }

P
Paolo Bonzini 已提交
317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333
    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
D
Dong Xu Wang 已提交
334
         * packets continuously instead of every 100ms.
P
Paolo Bonzini 已提交
335 336 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 386 387
         */
        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);
}

388 389 390 391
/***********************************************************/
void hw_error(const char *fmt, ...)
{
    va_list ap;
392
    CPUArchState *env;
393
    CPUState *cpu;
394 395 396 397 398

    va_start(ap, fmt);
    fprintf(stderr, "qemu: hardware error: ");
    vfprintf(stderr, fmt, ap);
    fprintf(stderr, "\n");
399 400 401
    for (env = first_cpu; env != NULL; env = env->next_cpu) {
        cpu = ENV_GET_CPU(env);
        fprintf(stderr, "CPU #%d:\n", cpu->cpu_index);
402
        cpu_dump_state(env, stderr, fprintf, CPU_DUMP_FPU);
403 404 405 406 407 408 409
    }
    va_end(ap);
    abort();
}

void cpu_synchronize_all_states(void)
{
410
    CPUArchState *cpu;
411 412 413 414 415 416 417 418

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

void cpu_synchronize_all_post_reset(void)
{
419
    CPUArchState *cpu;
420 421 422 423 424 425 426 427

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

void cpu_synchronize_all_post_init(void)
{
428
    CPUArchState *cpu;
429 430 431 432 433 434

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

435
bool cpu_is_stopped(CPUState *cpu)
M
Marcelo Tosatti 已提交
436
{
437
    return !runstate_is_running() || cpu->stopped;
M
Marcelo Tosatti 已提交
438 439
}

440
static void do_vm_stop(RunState state)
441
{
442
    if (runstate_is_running()) {
443 444
        cpu_disable_ticks();
        pause_all_vcpus();
445
        runstate_set(state);
446
        vm_state_notify(0, state);
447
        bdrv_drain_all();
448
        bdrv_flush_all();
449 450 451 452
        monitor_protocol_event(QEVENT_STOP, NULL);
    }
}

453
static bool cpu_can_run(CPUState *cpu)
454
{
A
Andreas Färber 已提交
455
    if (cpu->stop) {
456
        return false;
457
    }
458
    if (cpu->stopped || !runstate_is_running()) {
459
        return false;
460
    }
461
    return true;
462 463
}

464
static void cpu_handle_guest_debug(CPUArchState *env)
465
{
466 467
    CPUState *cpu = ENV_GET_CPU(env);

468
    gdb_set_stop_cpu(env);
469
    qemu_system_debug_request();
470
    cpu->stopped = true;
471 472
}

473 474 475 476 477 478 479 480
static void cpu_signal(int sig)
{
    if (cpu_single_env) {
        cpu_exit(cpu_single_env);
    }
    exit_request = 1;
}

481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519
#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);
}

520
static void qemu_kvm_eat_signals(CPUState *cpu)
521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540
{
    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:
541
            if (kvm_on_sigbus_vcpu(cpu, siginfo.si_code, siginfo.si_addr)) {
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556
                sigbus_reraise();
            }
            break;
        default:
            break;
        }

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

557 558 559 560 561
#else /* !CONFIG_LINUX */

static void qemu_init_sigbus(void)
{
}
562

563
static void qemu_kvm_eat_signals(CPUState *cpu)
564 565
{
}
566 567
#endif /* !CONFIG_LINUX */

568
#ifndef _WIN32
569 570 571 572
static void dummy_signal(int sig)
{
}

573
static void qemu_kvm_init_cpu_signals(CPUArchState *env)
574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606
{
    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);
    }
}

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);
}

607
#else /* _WIN32 */
608
static void qemu_kvm_init_cpu_signals(CPUArchState *env)
609
{
610 611
    abort();
}
612

613 614
static void qemu_tcg_init_cpu_signals(void)
{
615
}
616
#endif /* _WIN32 */
617

618
static QemuMutex qemu_global_mutex;
619 620
static QemuCond qemu_io_proceeded_cond;
static bool iothread_requesting_mutex;
621 622 623 624 625 626 627 628 629 630

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 已提交
631
static QemuCond qemu_work_cond;
632

P
Paolo Bonzini 已提交
633
void qemu_init_cpu_loop(void)
634
{
635
    qemu_init_sigbus();
636 637 638
    qemu_cond_init(&qemu_cpu_cond);
    qemu_cond_init(&qemu_pause_cond);
    qemu_cond_init(&qemu_work_cond);
639
    qemu_cond_init(&qemu_io_proceeded_cond);
640 641
    qemu_mutex_init(&qemu_global_mutex);

J
Jan Kiszka 已提交
642
    qemu_thread_get_self(&io_thread);
643 644
}

645
void run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data)
M
Marcelo Tosatti 已提交
646 647 648
{
    struct qemu_work_item wi;

649
    if (qemu_cpu_is_self(cpu)) {
M
Marcelo Tosatti 已提交
650 651 652 653 654 655
        func(data);
        return;
    }

    wi.func = func;
    wi.data = data;
656 657
    if (cpu->queued_work_first == NULL) {
        cpu->queued_work_first = &wi;
658
    } else {
659
        cpu->queued_work_last->next = &wi;
660
    }
661
    cpu->queued_work_last = &wi;
M
Marcelo Tosatti 已提交
662 663 664
    wi.next = NULL;
    wi.done = false;

665
    qemu_cpu_kick(cpu);
M
Marcelo Tosatti 已提交
666
    while (!wi.done) {
667
        CPUArchState *self_env = cpu_single_env;
M
Marcelo Tosatti 已提交
668 669 670 671 672 673

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

674
static void flush_queued_work(CPUState *cpu)
M
Marcelo Tosatti 已提交
675 676 677
{
    struct qemu_work_item *wi;

678
    if (cpu->queued_work_first == NULL) {
M
Marcelo Tosatti 已提交
679
        return;
680
    }
M
Marcelo Tosatti 已提交
681

682 683
    while ((wi = cpu->queued_work_first)) {
        cpu->queued_work_first = wi->next;
M
Marcelo Tosatti 已提交
684 685 686
        wi->func(wi->data);
        wi->done = true;
    }
687
    cpu->queued_work_last = NULL;
M
Marcelo Tosatti 已提交
688 689 690
    qemu_cond_broadcast(&qemu_work_cond);
}

691
static void qemu_wait_io_event_common(CPUState *cpu)
692
{
A
Andreas Färber 已提交
693 694
    if (cpu->stop) {
        cpu->stop = false;
695
        cpu->stopped = true;
696 697
        qemu_cond_signal(&qemu_pause_cond);
    }
698
    flush_queued_work(cpu);
699
    cpu->thread_kicked = false;
700 701
}

702
static void qemu_tcg_wait_io_event(void)
703
{
704
    CPUArchState *env;
705

706
    while (all_cpu_threads_idle()) {
707 708 709
       /* Start accounting real time to the virtual clock if the CPUs
          are idle.  */
        qemu_clock_warp(vm_clock);
710
        qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
711
    }
712

713 714 715
    while (iothread_requesting_mutex) {
        qemu_cond_wait(&qemu_io_proceeded_cond, &qemu_global_mutex);
    }
716 717

    for (env = first_cpu; env != NULL; env = env->next_cpu) {
718
        qemu_wait_io_event_common(ENV_GET_CPU(env));
719
    }
720 721
}

722
static void qemu_kvm_wait_io_event(CPUArchState *env)
723
{
A
Andreas Färber 已提交
724 725
    CPUState *cpu = ENV_GET_CPU(env);

726
    while (cpu_thread_is_idle(env)) {
A
Andreas Färber 已提交
727
        qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
728
    }
729

730
    qemu_kvm_eat_signals(cpu);
731
    qemu_wait_io_event_common(cpu);
732 733
}

734
static void *qemu_kvm_cpu_thread_fn(void *arg)
735
{
736
    CPUArchState *env = arg;
737
    CPUState *cpu = ENV_GET_CPU(env);
J
Jan Kiszka 已提交
738
    int r;
739

740
    qemu_mutex_lock(&qemu_global_mutex);
741
    qemu_thread_get_self(cpu->thread);
A
Andreas Färber 已提交
742
    cpu->thread_id = qemu_get_thread_id();
J
Jan Kiszka 已提交
743
    cpu_single_env = env;
744

745
    r = kvm_init_vcpu(cpu);
J
Jan Kiszka 已提交
746 747 748 749
    if (r < 0) {
        fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r));
        exit(1);
    }
750

751
    qemu_kvm_init_cpu_signals(env);
752 753

    /* signal CPU creation */
754
    cpu->created = true;
755 756 757
    qemu_cond_signal(&qemu_cpu_cond);

    while (1) {
758
        if (cpu_can_run(cpu)) {
759
            r = kvm_cpu_exec(env);
760
            if (r == EXCP_DEBUG) {
761
                cpu_handle_guest_debug(env);
762
            }
763
        }
764 765 766 767 768 769
        qemu_kvm_wait_io_event(env);
    }

    return NULL;
}

A
Anthony Liguori 已提交
770 771 772 773 774 775 776
static void *qemu_dummy_cpu_thread_fn(void *arg)
{
#ifdef _WIN32
    fprintf(stderr, "qtest is not supported under Windows\n");
    exit(1);
#else
    CPUArchState *env = arg;
777
    CPUState *cpu = ENV_GET_CPU(env);
A
Anthony Liguori 已提交
778 779 780 781
    sigset_t waitset;
    int r;

    qemu_mutex_lock_iothread();
782
    qemu_thread_get_self(cpu->thread);
A
Andreas Färber 已提交
783
    cpu->thread_id = qemu_get_thread_id();
A
Anthony Liguori 已提交
784 785 786 787 788

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

    /* signal CPU creation */
789
    cpu->created = true;
A
Anthony Liguori 已提交
790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805
    qemu_cond_signal(&qemu_cpu_cond);

    cpu_single_env = env;
    while (1) {
        cpu_single_env = NULL;
        qemu_mutex_unlock_iothread();
        do {
            int sig;
            r = sigwait(&waitset, &sig);
        } while (r == -1 && (errno == EAGAIN || errno == EINTR));
        if (r == -1) {
            perror("sigwait");
            exit(1);
        }
        qemu_mutex_lock_iothread();
        cpu_single_env = env;
806
        qemu_wait_io_event_common(cpu);
A
Anthony Liguori 已提交
807 808 809 810 811 812
    }

    return NULL;
#endif
}

J
Jan Kiszka 已提交
813 814
static void tcg_exec_all(void);

815
static void *qemu_tcg_cpu_thread_fn(void *arg)
816
{
817 818
    CPUState *cpu = arg;
    CPUArchState *env;
819

820
    qemu_tcg_init_cpu_signals();
821
    qemu_thread_get_self(cpu->thread);
822 823 824

    /* signal CPU creation */
    qemu_mutex_lock(&qemu_global_mutex);
825
    for (env = first_cpu; env != NULL; env = env->next_cpu) {
826
        cpu = ENV_GET_CPU(env);
A
Andreas Färber 已提交
827
        cpu->thread_id = qemu_get_thread_id();
828
        cpu->created = true;
829
    }
830 831
    qemu_cond_signal(&qemu_cpu_cond);

832
    /* wait for initial kick-off after machine start */
833
    while (ENV_GET_CPU(first_cpu)->stopped) {
834
        qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
835 836 837

        /* process any pending work */
        for (env = first_cpu; env != NULL; env = env->next_cpu) {
838
            qemu_wait_io_event_common(ENV_GET_CPU(env));
839
        }
840
    }
841 842

    while (1) {
J
Jan Kiszka 已提交
843
        tcg_exec_all();
P
Paolo Bonzini 已提交
844
        if (use_icount && qemu_clock_deadline(vm_clock) <= 0) {
845 846
            qemu_notify_event();
        }
847
        qemu_tcg_wait_io_event();
848 849 850 851 852
    }

    return NULL;
}

853
static void qemu_cpu_kick_thread(CPUState *cpu)
P
Paolo Bonzini 已提交
854 855 856 857
{
#ifndef _WIN32
    int err;

858
    err = pthread_kill(cpu->thread->thread, SIG_IPI);
P
Paolo Bonzini 已提交
859 860 861 862 863
    if (err) {
        fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
        exit(1);
    }
#else /* _WIN32 */
864
    if (!qemu_cpu_is_self(cpu)) {
865
        SuspendThread(cpu->hThread);
P
Paolo Bonzini 已提交
866
        cpu_signal(0);
867
        ResumeThread(cpu->hThread);
P
Paolo Bonzini 已提交
868 869 870 871
    }
#endif
}

872
void qemu_cpu_kick(CPUState *cpu)
873
{
A
Andreas Färber 已提交
874
    qemu_cond_broadcast(cpu->halt_cond);
875
    if (!tcg_enabled() && !cpu->thread_kicked) {
876
        qemu_cpu_kick_thread(cpu);
877
        cpu->thread_kicked = true;
878
    }
879 880
}

881
void qemu_cpu_kick_self(void)
882
{
883
#ifndef _WIN32
884
    assert(cpu_single_env);
885
    CPUState *cpu_single_cpu = ENV_GET_CPU(cpu_single_env);
886

887
    if (!cpu_single_cpu->thread_kicked) {
888
        qemu_cpu_kick_thread(cpu_single_cpu);
889
        cpu_single_cpu->thread_kicked = true;
890
    }
891 892 893
#else
    abort();
#endif
894 895
}

896
bool qemu_cpu_is_self(CPUState *cpu)
897
{
898
    return qemu_thread_is_self(cpu->thread);
899 900
}

J
Juan Quintela 已提交
901 902
static bool qemu_in_vcpu_thread(void)
{
903
    return cpu_single_env && qemu_cpu_is_self(ENV_GET_CPU(cpu_single_env));
J
Juan Quintela 已提交
904 905
}

906 907
void qemu_mutex_lock_iothread(void)
{
A
Anthony Liguori 已提交
908
    if (!tcg_enabled()) {
909
        qemu_mutex_lock(&qemu_global_mutex);
910
    } else {
911
        iothread_requesting_mutex = true;
912
        if (qemu_mutex_trylock(&qemu_global_mutex)) {
913
            qemu_cpu_kick_thread(ENV_GET_CPU(first_cpu));
914 915
            qemu_mutex_lock(&qemu_global_mutex);
        }
916 917
        iothread_requesting_mutex = false;
        qemu_cond_broadcast(&qemu_io_proceeded_cond);
918
    }
919 920 921 922 923 924 925 926 927
}

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

static int all_vcpus_paused(void)
{
928
    CPUArchState *penv = first_cpu;
929 930

    while (penv) {
931 932
        CPUState *pcpu = ENV_GET_CPU(penv);
        if (!pcpu->stopped) {
933
            return 0;
934
        }
935
        penv = penv->next_cpu;
936 937 938 939 940 941 942
    }

    return 1;
}

void pause_all_vcpus(void)
{
943
    CPUArchState *penv = first_cpu;
944

945
    qemu_clock_enable(vm_clock, false);
946
    while (penv) {
A
Andreas Färber 已提交
947 948
        CPUState *pcpu = ENV_GET_CPU(penv);
        pcpu->stop = true;
949
        qemu_cpu_kick(pcpu);
950
        penv = penv->next_cpu;
951 952
    }

J
Juan Quintela 已提交
953
    if (qemu_in_vcpu_thread()) {
954 955 956
        cpu_stop_current();
        if (!kvm_enabled()) {
            while (penv) {
A
Andreas Färber 已提交
957 958
                CPUState *pcpu = ENV_GET_CPU(penv);
                pcpu->stop = 0;
959
                pcpu->stopped = true;
960 961 962 963 964 965
                penv = penv->next_cpu;
            }
            return;
        }
    }

966
    while (!all_vcpus_paused()) {
967
        qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
968 969
        penv = first_cpu;
        while (penv) {
970
            qemu_cpu_kick(ENV_GET_CPU(penv));
971
            penv = penv->next_cpu;
972 973 974 975 976 977
        }
    }
}

void resume_all_vcpus(void)
{
978
    CPUArchState *penv = first_cpu;
979

980
    qemu_clock_enable(vm_clock, true);
981
    while (penv) {
A
Andreas Färber 已提交
982 983
        CPUState *pcpu = ENV_GET_CPU(penv);
        pcpu->stop = false;
984
        pcpu->stopped = false;
985
        qemu_cpu_kick(pcpu);
986
        penv = penv->next_cpu;
987 988 989
    }
}

990
static void qemu_tcg_init_vcpu(CPUState *cpu)
991 992 993
{
    /* share a single thread for all cpus with TCG */
    if (!tcg_cpu_thread) {
994
        cpu->thread = g_malloc0(sizeof(QemuThread));
A
Andreas Färber 已提交
995 996 997
        cpu->halt_cond = g_malloc0(sizeof(QemuCond));
        qemu_cond_init(cpu->halt_cond);
        tcg_halt_cond = cpu->halt_cond;
998
        qemu_thread_create(cpu->thread, qemu_tcg_cpu_thread_fn, cpu,
P
Paolo Bonzini 已提交
999 1000
                           QEMU_THREAD_JOINABLE);
#ifdef _WIN32
1001
        cpu->hThread = qemu_thread_get_handle(cpu->thread);
P
Paolo Bonzini 已提交
1002
#endif
1003
        while (!cpu->created) {
1004
            qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1005
        }
1006
        tcg_cpu_thread = cpu->thread;
1007
    } else {
1008
        cpu->thread = tcg_cpu_thread;
A
Andreas Färber 已提交
1009
        cpu->halt_cond = tcg_halt_cond;
1010 1011 1012
    }
}

1013
static void qemu_kvm_start_vcpu(CPUArchState *env)
1014
{
1015 1016 1017
    CPUState *cpu = ENV_GET_CPU(env);

    cpu->thread = g_malloc0(sizeof(QemuThread));
A
Andreas Färber 已提交
1018 1019
    cpu->halt_cond = g_malloc0(sizeof(QemuCond));
    qemu_cond_init(cpu->halt_cond);
1020
    qemu_thread_create(cpu->thread, qemu_kvm_cpu_thread_fn, env,
P
Paolo Bonzini 已提交
1021
                       QEMU_THREAD_JOINABLE);
1022
    while (!cpu->created) {
1023
        qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1024
    }
1025 1026
}

A
Anthony Liguori 已提交
1027 1028
static void qemu_dummy_start_vcpu(CPUArchState *env)
{
1029 1030 1031
    CPUState *cpu = ENV_GET_CPU(env);

    cpu->thread = g_malloc0(sizeof(QemuThread));
A
Andreas Färber 已提交
1032 1033
    cpu->halt_cond = g_malloc0(sizeof(QemuCond));
    qemu_cond_init(cpu->halt_cond);
1034
    qemu_thread_create(cpu->thread, qemu_dummy_cpu_thread_fn, env,
A
Anthony Liguori 已提交
1035
                       QEMU_THREAD_JOINABLE);
1036
    while (!cpu->created) {
A
Anthony Liguori 已提交
1037 1038 1039 1040
        qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
    }
}

1041 1042
void qemu_init_vcpu(void *_env)
{
1043
    CPUArchState *env = _env;
1044
    CPUState *cpu = ENV_GET_CPU(env);
1045

1046 1047
    cpu->nr_cores = smp_cores;
    cpu->nr_threads = smp_threads;
1048
    cpu->stopped = true;
1049
    if (kvm_enabled()) {
1050
        qemu_kvm_start_vcpu(env);
A
Anthony Liguori 已提交
1051
    } else if (tcg_enabled()) {
1052
        qemu_tcg_init_vcpu(cpu);
A
Anthony Liguori 已提交
1053 1054
    } else {
        qemu_dummy_start_vcpu(env);
1055
    }
1056 1057
}

1058
void cpu_stop_current(void)
1059
{
1060
    if (cpu_single_env) {
A
Andreas Färber 已提交
1061 1062
        CPUState *cpu_single_cpu = ENV_GET_CPU(cpu_single_env);
        cpu_single_cpu->stop = false;
1063
        cpu_single_cpu->stopped = true;
1064
        cpu_exit(cpu_single_env);
1065
        qemu_cond_signal(&qemu_pause_cond);
1066
    }
1067 1068
}

1069
void vm_stop(RunState state)
1070
{
J
Juan Quintela 已提交
1071
    if (qemu_in_vcpu_thread()) {
1072
        qemu_system_vmstop_request(state);
1073 1074 1075 1076
        /*
         * FIXME: should not return to device code in case
         * vm_stop() has been requested.
         */
1077
        cpu_stop_current();
1078 1079
        return;
    }
1080
    do_vm_stop(state);
1081 1082
}

1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
/* 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);
    }
}

1094
static int tcg_cpu_exec(CPUArchState *env)
1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109
{
    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 已提交
1110
        count = qemu_icount_round(qemu_clock_deadline(vm_clock));
1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
        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;
}

J
Jan Kiszka 已提交
1132
static void tcg_exec_all(void)
1133
{
1134 1135
    int r;

1136 1137 1138
    /* Account partial waits to the vm_clock.  */
    qemu_clock_warp(vm_clock);

1139
    if (next_cpu == NULL) {
1140
        next_cpu = first_cpu;
1141
    }
J
Jan Kiszka 已提交
1142
    for (; next_cpu != NULL && !exit_request; next_cpu = next_cpu->next_cpu) {
1143
        CPUArchState *env = next_cpu;
A
Andreas Färber 已提交
1144
        CPUState *cpu = ENV_GET_CPU(env);
1145 1146

        qemu_clock_enable(vm_clock,
1147
                          (env->singlestep_enabled & SSTEP_NOTIMER) == 0);
1148

1149
        if (cpu_can_run(cpu)) {
J
Jan Kiszka 已提交
1150
            r = tcg_cpu_exec(env);
1151
            if (r == EXCP_DEBUG) {
1152
                cpu_handle_guest_debug(env);
1153 1154
                break;
            }
1155
        } else if (cpu->stop || cpu->stopped) {
1156 1157 1158
            break;
        }
    }
J
Jan Kiszka 已提交
1159
    exit_request = 0;
1160 1161 1162 1163
}

void set_numa_modes(void)
{
1164
    CPUArchState *env;
1165
    CPUState *cpu;
1166 1167 1168
    int i;

    for (env = first_cpu; env != NULL; env = env->next_cpu) {
1169
        cpu = ENV_GET_CPU(env);
1170
        for (i = 0; i < nb_numa_nodes; i++) {
1171
            if (test_bit(cpu->cpu_index, node_cpumask[i])) {
1172
                cpu->numa_node = i;
1173 1174 1175 1176 1177
            }
        }
    }
}

1178
void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
1179 1180
{
    /* XXX: implement xxx_cpu_list for targets that still miss it */
P
Peter Maydell 已提交
1181 1182
#if defined(cpu_list)
    cpu_list(f, cpu_fprintf);
1183 1184
#endif
}
L
Luiz Capitulino 已提交
1185 1186 1187 1188

CpuInfoList *qmp_query_cpus(Error **errp)
{
    CpuInfoList *head = NULL, *cur_item = NULL;
1189
    CPUArchState *env;
L
Luiz Capitulino 已提交
1190

A
Andreas Färber 已提交
1191 1192
    for (env = first_cpu; env != NULL; env = env->next_cpu) {
        CPUState *cpu = ENV_GET_CPU(env);
L
Luiz Capitulino 已提交
1193 1194 1195 1196 1197 1198
        CpuInfoList *info;

        cpu_synchronize_state(env);

        info = g_malloc0(sizeof(*info));
        info->value = g_malloc0(sizeof(*info->value));
1199
        info->value->CPU = cpu->cpu_index;
L
Luiz Capitulino 已提交
1200 1201
        info->value->current = (env == first_cpu);
        info->value->halted = env->halted;
A
Andreas Färber 已提交
1202
        info->value->thread_id = cpu->thread_id;
L
Luiz Capitulino 已提交
1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229
#if defined(TARGET_I386)
        info->value->has_pc = true;
        info->value->pc = env->eip + env->segs[R_CS].base;
#elif defined(TARGET_PPC)
        info->value->has_nip = true;
        info->value->nip = env->nip;
#elif defined(TARGET_SPARC)
        info->value->has_pc = true;
        info->value->pc = env->pc;
        info->value->has_npc = true;
        info->value->npc = env->npc;
#elif defined(TARGET_MIPS)
        info->value->has_PC = true;
        info->value->PC = env->active_tc.PC;
#endif

        /* XXX: waiting for the qapi to support GSList */
        if (!cur_item) {
            head = cur_item = info;
        } else {
            cur_item->next = info;
            cur_item = info;
        }
    }

    return head;
}
L
Luiz Capitulino 已提交
1230 1231 1232 1233 1234 1235

void qmp_memsave(int64_t addr, int64_t size, const char *filename,
                 bool has_cpu, int64_t cpu_index, Error **errp)
{
    FILE *f;
    uint32_t l;
1236
    CPUArchState *env;
1237
    CPUState *cpu;
L
Luiz Capitulino 已提交
1238 1239 1240 1241 1242 1243
    uint8_t buf[1024];

    if (!has_cpu) {
        cpu_index = 0;
    }

1244 1245
    cpu = qemu_get_cpu(cpu_index);
    if (cpu == NULL) {
L
Luiz Capitulino 已提交
1246 1247 1248 1249
        error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
                  "a CPU number");
        return;
    }
1250
    env = cpu->env_ptr;
L
Luiz Capitulino 已提交
1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273

    f = fopen(filename, "wb");
    if (!f) {
        error_set(errp, QERR_OPEN_FILE_FAILED, filename);
        return;
    }

    while (size != 0) {
        l = sizeof(buf);
        if (l > size)
            l = size;
        cpu_memory_rw_debug(env, addr, buf, l, 0);
        if (fwrite(buf, 1, l, f) != l) {
            error_set(errp, QERR_IO_ERROR);
            goto exit;
        }
        addr += l;
        size -= l;
    }

exit:
    fclose(f);
}
L
Luiz Capitulino 已提交
1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303

void qmp_pmemsave(int64_t addr, int64_t size, const char *filename,
                  Error **errp)
{
    FILE *f;
    uint32_t l;
    uint8_t buf[1024];

    f = fopen(filename, "wb");
    if (!f) {
        error_set(errp, QERR_OPEN_FILE_FAILED, filename);
        return;
    }

    while (size != 0) {
        l = sizeof(buf);
        if (l > size)
            l = size;
        cpu_physical_memory_rw(addr, buf, l, 0);
        if (fwrite(buf, 1, l, f) != l) {
            error_set(errp, QERR_IO_ERROR);
            goto exit;
        }
        addr += l;
        size -= l;
    }

exit:
    fclose(f);
}
L
Luiz Capitulino 已提交
1304 1305 1306 1307

void qmp_inject_nmi(Error **errp)
{
#if defined(TARGET_I386)
1308
    CPUArchState *env;
L
Luiz Capitulino 已提交
1309 1310

    for (env = first_cpu; env != NULL; env = env->next_cpu) {
1311 1312 1313 1314 1315
        if (!env->apic_state) {
            cpu_interrupt(env, CPU_INTERRUPT_NMI);
        } else {
            apic_deliver_nmi(env->apic_state);
        }
L
Luiz Capitulino 已提交
1316 1317 1318 1319 1320
    }
#else
    error_set(errp, QERR_UNSUPPORTED);
#endif
}