cpus.c 33.7 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
static bool cpu_thread_is_idle(CPUState *cpu)
66
{
67
    if (cpu->stop || cpu->queued_work_first) {
68 69
        return false;
    }
70
    if (cpu->stopped || !runstate_is_running()) {
71 72
        return true;
    }
73
    if (!cpu->halted || qemu_cpu_has_work(cpu) ||
74
        kvm_async_interrupts_enabled()) {
75 76 77 78 79 80 81 82 83 84
        return false;
    }
    return true;
}

static bool all_cpu_threads_idle(void)
{
    CPUArchState *env;

    for (env = first_cpu; env != NULL; env = env->next_cpu) {
85
        if (!cpu_thread_is_idle(ENV_GET_CPU(env))) {
86 87 88 89 90 91
            return false;
        }
    }
    return true;
}

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

    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 已提交
270 271 272 273 274 275 276 277 278 279 280 281 282 283
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 已提交
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
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 已提交
310 311 312 313 314
    if (qtest_enabled()) {
        /* When testing, qtest commands advance icount.  */
	return;
    }

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

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

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

void cpu_synchronize_all_states(void)
{
408
    CPUArchState *env;
409

410 411
    for (env = first_cpu; env; env = env->next_cpu) {
        cpu_synchronize_state(ENV_GET_CPU(env));
412 413 414 415 416
    }
}

void cpu_synchronize_all_post_reset(void)
{
417
    CPUArchState *cpu;
418 419

    for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
420
        cpu_synchronize_post_reset(ENV_GET_CPU(cpu));
421 422 423 424 425
    }
}

void cpu_synchronize_all_post_init(void)
{
426
    CPUArchState *cpu;
427 428

    for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
429
        cpu_synchronize_post_init(ENV_GET_CPU(cpu));
430 431 432
    }
}

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

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

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

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

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

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

479 480 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
#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);
}

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

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

555 556 557 558 559
#else /* !CONFIG_LINUX */

static void qemu_init_sigbus(void)
{
}
560

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

566
#ifndef _WIN32
567 568 569 570
static void dummy_signal(int sig)
{
}

571
static void qemu_kvm_init_cpu_signals(CPUArchState *env)
572 573 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
{
    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);
}

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

611 612
static void qemu_tcg_init_cpu_signals(void)
{
613
}
614
#endif /* _WIN32 */
615

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

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 已提交
629
static QemuCond qemu_work_cond;
630

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

J
Jan Kiszka 已提交
640
    qemu_thread_get_self(&io_thread);
641 642
}

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

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

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

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

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

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

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

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

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

700
static void qemu_tcg_wait_io_event(void)
701
{
702
    CPUArchState *env;
703

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

711 712 713
    while (iothread_requesting_mutex) {
        qemu_cond_wait(&qemu_io_proceeded_cond, &qemu_global_mutex);
    }
714 715

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

720
static void qemu_kvm_wait_io_event(CPUState *cpu)
721
{
722
    while (cpu_thread_is_idle(cpu)) {
A
Andreas Färber 已提交
723
        qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
724
    }
725

726
    qemu_kvm_eat_signals(cpu);
727
    qemu_wait_io_event_common(cpu);
728 729
}

730
static void *qemu_kvm_cpu_thread_fn(void *arg)
731
{
732
    CPUArchState *env = arg;
733
    CPUState *cpu = ENV_GET_CPU(env);
J
Jan Kiszka 已提交
734
    int r;
735

736
    qemu_mutex_lock(&qemu_global_mutex);
737
    qemu_thread_get_self(cpu->thread);
A
Andreas Färber 已提交
738
    cpu->thread_id = qemu_get_thread_id();
J
Jan Kiszka 已提交
739
    cpu_single_env = env;
740

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

747
    qemu_kvm_init_cpu_signals(env);
748 749

    /* signal CPU creation */
750
    cpu->created = true;
751 752 753
    qemu_cond_signal(&qemu_cpu_cond);

    while (1) {
754
        if (cpu_can_run(cpu)) {
755
            r = kvm_cpu_exec(env);
756
            if (r == EXCP_DEBUG) {
757
                cpu_handle_guest_debug(env);
758
            }
759
        }
760
        qemu_kvm_wait_io_event(cpu);
761 762 763 764 765
    }

    return NULL;
}

A
Anthony Liguori 已提交
766 767 768 769 770 771 772
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;
773
    CPUState *cpu = ENV_GET_CPU(env);
A
Anthony Liguori 已提交
774 775 776 777
    sigset_t waitset;
    int r;

    qemu_mutex_lock_iothread();
778
    qemu_thread_get_self(cpu->thread);
A
Andreas Färber 已提交
779
    cpu->thread_id = qemu_get_thread_id();
A
Anthony Liguori 已提交
780 781 782 783 784

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

    /* signal CPU creation */
785
    cpu->created = true;
A
Anthony Liguori 已提交
786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801
    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;
802
        qemu_wait_io_event_common(cpu);
A
Anthony Liguori 已提交
803 804 805 806 807 808
    }

    return NULL;
#endif
}

J
Jan Kiszka 已提交
809 810
static void tcg_exec_all(void);

811 812 813 814 815 816
static void tcg_signal_cpu_creation(CPUState *cpu, void *data)
{
    cpu->thread_id = qemu_get_thread_id();
    cpu->created = true;
}

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

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

    qemu_mutex_lock(&qemu_global_mutex);
826
    qemu_for_each_cpu(tcg_signal_cpu_creation, NULL);
827 828
    qemu_cond_signal(&qemu_cpu_cond);

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

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

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

    return NULL;
}

850
static void qemu_cpu_kick_thread(CPUState *cpu)
P
Paolo Bonzini 已提交
851 852 853 854
{
#ifndef _WIN32
    int err;

855
    err = pthread_kill(cpu->thread->thread, SIG_IPI);
P
Paolo Bonzini 已提交
856 857 858 859 860
    if (err) {
        fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
        exit(1);
    }
#else /* _WIN32 */
861
    if (!qemu_cpu_is_self(cpu)) {
862 863 864
        CONTEXT tcgContext;

        if (SuspendThread(cpu->hThread) == (DWORD)-1) {
865
            fprintf(stderr, "qemu:%s: GetLastError:%lu\n", __func__,
866 867 868 869 870 871 872 873 874 875 876 877
                    GetLastError());
            exit(1);
        }

        /* On multi-core systems, we are not sure that the thread is actually
         * suspended until we can get the context.
         */
        tcgContext.ContextFlags = CONTEXT_CONTROL;
        while (GetThreadContext(cpu->hThread, &tcgContext) != 0) {
            continue;
        }

P
Paolo Bonzini 已提交
878
        cpu_signal(0);
879 880

        if (ResumeThread(cpu->hThread) == (DWORD)-1) {
881
            fprintf(stderr, "qemu:%s: GetLastError:%lu\n", __func__,
882 883 884
                    GetLastError());
            exit(1);
        }
P
Paolo Bonzini 已提交
885 886 887 888
    }
#endif
}

889
void qemu_cpu_kick(CPUState *cpu)
890
{
A
Andreas Färber 已提交
891
    qemu_cond_broadcast(cpu->halt_cond);
892
    if (!tcg_enabled() && !cpu->thread_kicked) {
893
        qemu_cpu_kick_thread(cpu);
894
        cpu->thread_kicked = true;
895
    }
896 897
}

898
void qemu_cpu_kick_self(void)
899
{
900
#ifndef _WIN32
901
    assert(cpu_single_env);
902
    CPUState *cpu_single_cpu = ENV_GET_CPU(cpu_single_env);
903

904
    if (!cpu_single_cpu->thread_kicked) {
905
        qemu_cpu_kick_thread(cpu_single_cpu);
906
        cpu_single_cpu->thread_kicked = true;
907
    }
908 909 910
#else
    abort();
#endif
911 912
}

913
bool qemu_cpu_is_self(CPUState *cpu)
914
{
915
    return qemu_thread_is_self(cpu->thread);
916 917
}

J
Juan Quintela 已提交
918 919
static bool qemu_in_vcpu_thread(void)
{
920
    return cpu_single_env && qemu_cpu_is_self(ENV_GET_CPU(cpu_single_env));
J
Juan Quintela 已提交
921 922
}

923 924
void qemu_mutex_lock_iothread(void)
{
A
Anthony Liguori 已提交
925
    if (!tcg_enabled()) {
926
        qemu_mutex_lock(&qemu_global_mutex);
927
    } else {
928
        iothread_requesting_mutex = true;
929
        if (qemu_mutex_trylock(&qemu_global_mutex)) {
930
            qemu_cpu_kick_thread(ENV_GET_CPU(first_cpu));
931 932
            qemu_mutex_lock(&qemu_global_mutex);
        }
933 934
        iothread_requesting_mutex = false;
        qemu_cond_broadcast(&qemu_io_proceeded_cond);
935
    }
936 937 938 939 940 941 942 943 944
}

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

static int all_vcpus_paused(void)
{
945
    CPUArchState *penv = first_cpu;
946 947

    while (penv) {
948 949
        CPUState *pcpu = ENV_GET_CPU(penv);
        if (!pcpu->stopped) {
950
            return 0;
951
        }
952
        penv = penv->next_cpu;
953 954 955 956 957 958 959
    }

    return 1;
}

void pause_all_vcpus(void)
{
960
    CPUArchState *penv = first_cpu;
961

962
    qemu_clock_enable(vm_clock, false);
963
    while (penv) {
A
Andreas Färber 已提交
964 965
        CPUState *pcpu = ENV_GET_CPU(penv);
        pcpu->stop = true;
966
        qemu_cpu_kick(pcpu);
967
        penv = penv->next_cpu;
968 969
    }

J
Juan Quintela 已提交
970
    if (qemu_in_vcpu_thread()) {
971 972
        cpu_stop_current();
        if (!kvm_enabled()) {
973
            penv = first_cpu;
974
            while (penv) {
A
Andreas Färber 已提交
975
                CPUState *pcpu = ENV_GET_CPU(penv);
976
                pcpu->stop = false;
977
                pcpu->stopped = true;
978 979 980 981 982 983
                penv = penv->next_cpu;
            }
            return;
        }
    }

984
    while (!all_vcpus_paused()) {
985
        qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
986 987
        penv = first_cpu;
        while (penv) {
988
            qemu_cpu_kick(ENV_GET_CPU(penv));
989
            penv = penv->next_cpu;
990 991 992 993
        }
    }
}

994 995 996 997 998 999 1000
void cpu_resume(CPUState *cpu)
{
    cpu->stop = false;
    cpu->stopped = false;
    qemu_cpu_kick(cpu);
}

1001 1002
void resume_all_vcpus(void)
{
1003
    CPUArchState *penv = first_cpu;
1004

1005
    qemu_clock_enable(vm_clock, true);
1006
    while (penv) {
A
Andreas Färber 已提交
1007
        CPUState *pcpu = ENV_GET_CPU(penv);
1008
        cpu_resume(pcpu);
1009
        penv = penv->next_cpu;
1010 1011 1012
    }
}

1013
static void qemu_tcg_init_vcpu(CPUState *cpu)
1014 1015 1016
{
    /* share a single thread for all cpus with TCG */
    if (!tcg_cpu_thread) {
1017
        cpu->thread = g_malloc0(sizeof(QemuThread));
A
Andreas Färber 已提交
1018 1019 1020
        cpu->halt_cond = g_malloc0(sizeof(QemuCond));
        qemu_cond_init(cpu->halt_cond);
        tcg_halt_cond = cpu->halt_cond;
1021
        qemu_thread_create(cpu->thread, qemu_tcg_cpu_thread_fn, cpu,
P
Paolo Bonzini 已提交
1022 1023
                           QEMU_THREAD_JOINABLE);
#ifdef _WIN32
1024
        cpu->hThread = qemu_thread_get_handle(cpu->thread);
P
Paolo Bonzini 已提交
1025
#endif
1026
        while (!cpu->created) {
1027
            qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1028
        }
1029
        tcg_cpu_thread = cpu->thread;
1030
    } else {
1031
        cpu->thread = tcg_cpu_thread;
A
Andreas Färber 已提交
1032
        cpu->halt_cond = tcg_halt_cond;
1033 1034 1035
    }
}

1036
static void qemu_kvm_start_vcpu(CPUArchState *env)
1037
{
1038 1039 1040
    CPUState *cpu = ENV_GET_CPU(env);

    cpu->thread = g_malloc0(sizeof(QemuThread));
A
Andreas Färber 已提交
1041 1042
    cpu->halt_cond = g_malloc0(sizeof(QemuCond));
    qemu_cond_init(cpu->halt_cond);
1043
    qemu_thread_create(cpu->thread, qemu_kvm_cpu_thread_fn, env,
P
Paolo Bonzini 已提交
1044
                       QEMU_THREAD_JOINABLE);
1045
    while (!cpu->created) {
1046
        qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1047
    }
1048 1049
}

A
Anthony Liguori 已提交
1050 1051
static void qemu_dummy_start_vcpu(CPUArchState *env)
{
1052 1053 1054
    CPUState *cpu = ENV_GET_CPU(env);

    cpu->thread = g_malloc0(sizeof(QemuThread));
A
Andreas Färber 已提交
1055 1056
    cpu->halt_cond = g_malloc0(sizeof(QemuCond));
    qemu_cond_init(cpu->halt_cond);
1057
    qemu_thread_create(cpu->thread, qemu_dummy_cpu_thread_fn, env,
A
Anthony Liguori 已提交
1058
                       QEMU_THREAD_JOINABLE);
1059
    while (!cpu->created) {
A
Anthony Liguori 已提交
1060 1061 1062 1063
        qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
    }
}

1064 1065
void qemu_init_vcpu(void *_env)
{
1066
    CPUArchState *env = _env;
1067
    CPUState *cpu = ENV_GET_CPU(env);
1068

1069 1070
    cpu->nr_cores = smp_cores;
    cpu->nr_threads = smp_threads;
1071
    cpu->stopped = true;
1072
    if (kvm_enabled()) {
1073
        qemu_kvm_start_vcpu(env);
A
Anthony Liguori 已提交
1074
    } else if (tcg_enabled()) {
1075
        qemu_tcg_init_vcpu(cpu);
A
Anthony Liguori 已提交
1076 1077
    } else {
        qemu_dummy_start_vcpu(env);
1078
    }
1079 1080
}

1081
void cpu_stop_current(void)
1082
{
1083
    if (cpu_single_env) {
A
Andreas Färber 已提交
1084 1085
        CPUState *cpu_single_cpu = ENV_GET_CPU(cpu_single_env);
        cpu_single_cpu->stop = false;
1086
        cpu_single_cpu->stopped = true;
1087
        cpu_exit(cpu_single_cpu);
1088
        qemu_cond_signal(&qemu_pause_cond);
1089
    }
1090 1091
}

1092
void vm_stop(RunState state)
1093
{
J
Juan Quintela 已提交
1094
    if (qemu_in_vcpu_thread()) {
1095
        qemu_system_vmstop_request(state);
1096 1097 1098 1099
        /*
         * FIXME: should not return to device code in case
         * vm_stop() has been requested.
         */
1100
        cpu_stop_current();
1101 1102
        return;
    }
1103
    do_vm_stop(state);
1104 1105
}

1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116
/* 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);
    }
}

1117
static int tcg_cpu_exec(CPUArchState *env)
1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132
{
    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 已提交
1133
        count = qemu_icount_round(qemu_clock_deadline(vm_clock));
1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154
        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 已提交
1155
static void tcg_exec_all(void)
1156
{
1157 1158
    int r;

1159 1160 1161
    /* Account partial waits to the vm_clock.  */
    qemu_clock_warp(vm_clock);

1162
    if (next_cpu == NULL) {
1163
        next_cpu = first_cpu;
1164
    }
J
Jan Kiszka 已提交
1165
    for (; next_cpu != NULL && !exit_request; next_cpu = next_cpu->next_cpu) {
1166
        CPUArchState *env = next_cpu;
A
Andreas Färber 已提交
1167
        CPUState *cpu = ENV_GET_CPU(env);
1168 1169

        qemu_clock_enable(vm_clock,
1170
                          (env->singlestep_enabled & SSTEP_NOTIMER) == 0);
1171

1172
        if (cpu_can_run(cpu)) {
J
Jan Kiszka 已提交
1173
            r = tcg_cpu_exec(env);
1174
            if (r == EXCP_DEBUG) {
1175
                cpu_handle_guest_debug(env);
1176 1177
                break;
            }
1178
        } else if (cpu->stop || cpu->stopped) {
1179 1180 1181
            break;
        }
    }
J
Jan Kiszka 已提交
1182
    exit_request = 0;
1183 1184 1185 1186
}

void set_numa_modes(void)
{
1187
    CPUArchState *env;
1188
    CPUState *cpu;
1189 1190 1191
    int i;

    for (env = first_cpu; env != NULL; env = env->next_cpu) {
1192
        cpu = ENV_GET_CPU(env);
1193
        for (i = 0; i < nb_numa_nodes; i++) {
1194
            if (test_bit(cpu->cpu_index, node_cpumask[i])) {
1195
                cpu->numa_node = i;
1196 1197 1198 1199 1200
            }
        }
    }
}

1201
void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
1202 1203
{
    /* XXX: implement xxx_cpu_list for targets that still miss it */
P
Peter Maydell 已提交
1204 1205
#if defined(cpu_list)
    cpu_list(f, cpu_fprintf);
1206 1207
#endif
}
L
Luiz Capitulino 已提交
1208 1209 1210 1211

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

A
Andreas Färber 已提交
1214 1215
    for (env = first_cpu; env != NULL; env = env->next_cpu) {
        CPUState *cpu = ENV_GET_CPU(env);
L
Luiz Capitulino 已提交
1216 1217
        CpuInfoList *info;

1218
        cpu_synchronize_state(cpu);
L
Luiz Capitulino 已提交
1219 1220 1221

        info = g_malloc0(sizeof(*info));
        info->value = g_malloc0(sizeof(*info->value));
1222
        info->value->CPU = cpu->cpu_index;
L
Luiz Capitulino 已提交
1223
        info->value->current = (env == first_cpu);
1224
        info->value->halted = cpu->halted;
A
Andreas Färber 已提交
1225
        info->value->thread_id = cpu->thread_id;
L
Luiz Capitulino 已提交
1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252
#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 已提交
1253 1254 1255 1256 1257 1258

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;
1259
    CPUArchState *env;
1260
    CPUState *cpu;
L
Luiz Capitulino 已提交
1261 1262 1263 1264 1265 1266
    uint8_t buf[1024];

    if (!has_cpu) {
        cpu_index = 0;
    }

1267 1268
    cpu = qemu_get_cpu(cpu_index);
    if (cpu == NULL) {
L
Luiz Capitulino 已提交
1269 1270 1271 1272
        error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
                  "a CPU number");
        return;
    }
1273
    env = cpu->env_ptr;
L
Luiz Capitulino 已提交
1274 1275 1276

    f = fopen(filename, "wb");
    if (!f) {
1277
        error_setg_file_open(errp, errno, filename);
L
Luiz Capitulino 已提交
1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296
        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 已提交
1297 1298 1299 1300 1301 1302 1303 1304 1305 1306

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) {
1307
        error_setg_file_open(errp, errno, filename);
L
Luiz Capitulino 已提交
1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
        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 已提交
1327 1328 1329 1330

void qmp_inject_nmi(Error **errp)
{
#if defined(TARGET_I386)
1331
    CPUArchState *env;
L
Luiz Capitulino 已提交
1332 1333

    for (env = first_cpu; env != NULL; env = env->next_cpu) {
1334
        if (!env->apic_state) {
1335
            cpu_interrupt(CPU(x86_env_get_cpu(env)), CPU_INTERRUPT_NMI);
1336 1337 1338
        } else {
            apic_deliver_nmi(env->apic_state);
        }
L
Luiz Capitulino 已提交
1339 1340 1341 1342 1343
    }
#else
    error_set(errp, QERR_UNSUPPORTED);
#endif
}