net/dp8393x: remove check of runt packets
[qemu/ar7.git] / cpus.c
bloba822ce3d80514ffe75ea77421c95a563c086ece6
1 /*
2 * QEMU System Emulator
4 * Copyright (c) 2003-2008 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
25 /* Needed early for CONFIG_BSD etc. */
26 #include "config-host.h"
28 #include "monitor/monitor.h"
29 #include "qapi/qmp/qerror.h"
30 #include "qemu/error-report.h"
31 #include "sysemu/sysemu.h"
32 #include "exec/gdbstub.h"
33 #include "sysemu/dma.h"
34 #include "sysemu/kvm.h"
35 #include "qmp-commands.h"
37 #include "qemu/thread.h"
38 #include "sysemu/cpus.h"
39 #include "sysemu/qtest.h"
40 #include "qemu/main-loop.h"
41 #include "qemu/bitmap.h"
42 #include "qemu/seqlock.h"
43 #include "qapi-event.h"
44 #include "hw/nmi.h"
46 #ifndef _WIN32
47 #include "qemu/compatfd.h"
48 #endif
50 #ifdef CONFIG_LINUX
52 #include <sys/prctl.h>
54 #ifndef PR_MCE_KILL
55 #define PR_MCE_KILL 33
56 #endif
58 #ifndef PR_MCE_KILL_SET
59 #define PR_MCE_KILL_SET 1
60 #endif
62 #ifndef PR_MCE_KILL_EARLY
63 #define PR_MCE_KILL_EARLY 1
64 #endif
66 #endif /* CONFIG_LINUX */
68 static CPUState *next_cpu;
69 int64_t max_delay;
70 int64_t max_advance;
72 bool cpu_is_stopped(CPUState *cpu)
74 return cpu->stopped || !runstate_is_running();
77 static bool cpu_thread_is_idle(CPUState *cpu)
79 if (cpu->stop || cpu->queued_work_first) {
80 return false;
82 if (cpu_is_stopped(cpu)) {
83 return true;
85 if (!cpu->halted || cpu_has_work(cpu) ||
86 kvm_halt_in_kernel()) {
87 return false;
89 return true;
92 static bool all_cpu_threads_idle(void)
94 CPUState *cpu;
96 CPU_FOREACH(cpu) {
97 if (!cpu_thread_is_idle(cpu)) {
98 return false;
101 return true;
104 /***********************************************************/
105 /* guest cycle counter */
107 /* Protected by TimersState seqlock */
109 static bool icount_sleep = true;
110 static int64_t vm_clock_warp_start = -1;
111 /* Conversion factor from emulated instructions to virtual clock ticks. */
112 static int icount_time_shift;
113 /* Arbitrarily pick 1MIPS as the minimum allowable speed. */
114 #define MAX_ICOUNT_SHIFT 10
116 static QEMUTimer *icount_rt_timer;
117 static QEMUTimer *icount_vm_timer;
118 static QEMUTimer *icount_warp_timer;
120 typedef struct TimersState {
121 /* Protected by BQL. */
122 int64_t cpu_ticks_prev;
123 int64_t cpu_ticks_offset;
125 /* cpu_clock_offset can be read out of BQL, so protect it with
126 * this lock.
128 QemuSeqLock vm_clock_seqlock;
129 int64_t cpu_clock_offset;
130 int32_t cpu_ticks_enabled;
131 int64_t dummy;
133 /* Compensate for varying guest execution speed. */
134 int64_t qemu_icount_bias;
135 /* Only written by TCG thread */
136 int64_t qemu_icount;
137 } TimersState;
139 static TimersState timers_state;
141 int64_t cpu_get_icount_raw(void)
143 int64_t icount;
144 CPUState *cpu = current_cpu;
146 icount = timers_state.qemu_icount;
147 if (cpu) {
148 if (!cpu_can_do_io(cpu)) {
149 fprintf(stderr, "Bad icount read\n");
150 exit(1);
152 icount -= (cpu->icount_decr.u16.low + cpu->icount_extra);
154 return icount;
157 /* Return the virtual CPU time, based on the instruction counter. */
158 static int64_t cpu_get_icount_locked(void)
160 int64_t icount = cpu_get_icount_raw();
161 return timers_state.qemu_icount_bias + cpu_icount_to_ns(icount);
164 int64_t cpu_get_icount(void)
166 int64_t icount;
167 unsigned start;
169 do {
170 start = seqlock_read_begin(&timers_state.vm_clock_seqlock);
171 icount = cpu_get_icount_locked();
172 } while (seqlock_read_retry(&timers_state.vm_clock_seqlock, start));
174 return icount;
177 int64_t cpu_icount_to_ns(int64_t icount)
179 return icount << icount_time_shift;
182 /* return the host CPU cycle counter and handle stop/restart */
183 /* Caller must hold the BQL */
184 int64_t cpu_get_ticks(void)
186 int64_t ticks;
188 if (use_icount) {
189 return cpu_get_icount();
192 ticks = timers_state.cpu_ticks_offset;
193 if (timers_state.cpu_ticks_enabled) {
194 ticks += cpu_get_real_ticks();
197 if (timers_state.cpu_ticks_prev > ticks) {
198 /* Note: non increasing ticks may happen if the host uses
199 software suspend */
200 timers_state.cpu_ticks_offset += timers_state.cpu_ticks_prev - ticks;
201 ticks = timers_state.cpu_ticks_prev;
204 timers_state.cpu_ticks_prev = ticks;
205 return ticks;
208 static int64_t cpu_get_clock_locked(void)
210 int64_t ticks;
212 ticks = timers_state.cpu_clock_offset;
213 if (timers_state.cpu_ticks_enabled) {
214 ticks += get_clock();
217 return ticks;
220 /* return the host CPU monotonic timer and handle stop/restart */
221 int64_t cpu_get_clock(void)
223 int64_t ti;
224 unsigned start;
226 do {
227 start = seqlock_read_begin(&timers_state.vm_clock_seqlock);
228 ti = cpu_get_clock_locked();
229 } while (seqlock_read_retry(&timers_state.vm_clock_seqlock, start));
231 return ti;
234 /* enable cpu_get_ticks()
235 * Caller must hold BQL which server as mutex for vm_clock_seqlock.
237 void cpu_enable_ticks(void)
239 /* Here, the really thing protected by seqlock is cpu_clock_offset. */
240 seqlock_write_lock(&timers_state.vm_clock_seqlock);
241 if (!timers_state.cpu_ticks_enabled) {
242 timers_state.cpu_ticks_offset -= cpu_get_real_ticks();
243 timers_state.cpu_clock_offset -= get_clock();
244 timers_state.cpu_ticks_enabled = 1;
246 seqlock_write_unlock(&timers_state.vm_clock_seqlock);
249 /* disable cpu_get_ticks() : the clock is stopped. You must not call
250 * cpu_get_ticks() after that.
251 * Caller must hold BQL which server as mutex for vm_clock_seqlock.
253 void cpu_disable_ticks(void)
255 /* Here, the really thing protected by seqlock is cpu_clock_offset. */
256 seqlock_write_lock(&timers_state.vm_clock_seqlock);
257 if (timers_state.cpu_ticks_enabled) {
258 timers_state.cpu_ticks_offset += cpu_get_real_ticks();
259 timers_state.cpu_clock_offset = cpu_get_clock_locked();
260 timers_state.cpu_ticks_enabled = 0;
262 seqlock_write_unlock(&timers_state.vm_clock_seqlock);
265 /* Correlation between real and virtual time is always going to be
266 fairly approximate, so ignore small variation.
267 When the guest is idle real and virtual time will be aligned in
268 the IO wait loop. */
269 #define ICOUNT_WOBBLE (get_ticks_per_sec() / 10)
271 static void icount_adjust(void)
273 int64_t cur_time;
274 int64_t cur_icount;
275 int64_t delta;
277 /* Protected by TimersState mutex. */
278 static int64_t last_delta;
280 /* If the VM is not running, then do nothing. */
281 if (!runstate_is_running()) {
282 return;
285 seqlock_write_lock(&timers_state.vm_clock_seqlock);
286 cur_time = cpu_get_clock_locked();
287 cur_icount = cpu_get_icount_locked();
289 delta = cur_icount - cur_time;
290 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
291 if (delta > 0
292 && last_delta + ICOUNT_WOBBLE < delta * 2
293 && icount_time_shift > 0) {
294 /* The guest is getting too far ahead. Slow time down. */
295 icount_time_shift--;
297 if (delta < 0
298 && last_delta - ICOUNT_WOBBLE > delta * 2
299 && icount_time_shift < MAX_ICOUNT_SHIFT) {
300 /* The guest is getting too far behind. Speed time up. */
301 icount_time_shift++;
303 last_delta = delta;
304 timers_state.qemu_icount_bias = cur_icount
305 - (timers_state.qemu_icount << icount_time_shift);
306 seqlock_write_unlock(&timers_state.vm_clock_seqlock);
309 static void icount_adjust_rt(void *opaque)
311 timer_mod(icount_rt_timer,
312 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT) + 1000);
313 icount_adjust();
316 static void icount_adjust_vm(void *opaque)
318 timer_mod(icount_vm_timer,
319 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
320 get_ticks_per_sec() / 10);
321 icount_adjust();
324 static int64_t qemu_icount_round(int64_t count)
326 return (count + (1 << icount_time_shift) - 1) >> icount_time_shift;
329 static void icount_warp_rt(void *opaque)
331 /* The icount_warp_timer is rescheduled soon after vm_clock_warp_start
332 * changes from -1 to another value, so the race here is okay.
334 if (atomic_read(&vm_clock_warp_start) == -1) {
335 return;
338 seqlock_write_lock(&timers_state.vm_clock_seqlock);
339 if (runstate_is_running()) {
340 int64_t clock = cpu_get_clock_locked();
341 int64_t warp_delta;
343 warp_delta = clock - vm_clock_warp_start;
344 if (use_icount == 2) {
346 * In adaptive mode, do not let QEMU_CLOCK_VIRTUAL run too
347 * far ahead of real time.
349 int64_t cur_icount = cpu_get_icount_locked();
350 int64_t delta = clock - cur_icount;
351 warp_delta = MIN(warp_delta, delta);
353 timers_state.qemu_icount_bias += warp_delta;
355 vm_clock_warp_start = -1;
356 seqlock_write_unlock(&timers_state.vm_clock_seqlock);
358 if (qemu_clock_expired(QEMU_CLOCK_VIRTUAL)) {
359 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
363 void qtest_clock_warp(int64_t dest)
365 int64_t clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
366 AioContext *aio_context;
367 assert(qtest_enabled());
368 aio_context = qemu_get_aio_context();
369 while (clock < dest) {
370 int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
371 int64_t warp = qemu_soonest_timeout(dest - clock, deadline);
373 seqlock_write_lock(&timers_state.vm_clock_seqlock);
374 timers_state.qemu_icount_bias += warp;
375 seqlock_write_unlock(&timers_state.vm_clock_seqlock);
377 qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
378 timerlist_run_timers(aio_context->tlg.tl[QEMU_CLOCK_VIRTUAL]);
379 clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
381 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
384 void qemu_clock_warp(QEMUClockType type)
386 int64_t clock;
387 int64_t deadline;
390 * There are too many global variables to make the "warp" behavior
391 * applicable to other clocks. But a clock argument removes the
392 * need for if statements all over the place.
394 if (type != QEMU_CLOCK_VIRTUAL || !use_icount) {
395 return;
398 if (icount_sleep) {
400 * If the CPUs have been sleeping, advance QEMU_CLOCK_VIRTUAL timer now.
401 * This ensures that the deadline for the timer is computed correctly
402 * below.
403 * This also makes sure that the insn counter is synchronized before
404 * the CPU starts running, in case the CPU is woken by an event other
405 * than the earliest QEMU_CLOCK_VIRTUAL timer.
407 icount_warp_rt(NULL);
408 timer_del(icount_warp_timer);
410 if (!all_cpu_threads_idle()) {
411 return;
414 if (qtest_enabled()) {
415 /* When testing, qtest commands advance icount. */
416 return;
419 /* We want to use the earliest deadline from ALL vm_clocks */
420 clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT);
421 deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
422 if (deadline < 0) {
423 static bool notified;
424 if (!icount_sleep && !notified) {
425 error_report("WARNING: icount sleep disabled and no active timers");
426 notified = true;
428 return;
431 if (deadline > 0) {
433 * Ensure QEMU_CLOCK_VIRTUAL proceeds even when the virtual CPU goes to
434 * sleep. Otherwise, the CPU might be waiting for a future timer
435 * interrupt to wake it up, but the interrupt never comes because
436 * the vCPU isn't running any insns and thus doesn't advance the
437 * QEMU_CLOCK_VIRTUAL.
439 if (!icount_sleep) {
441 * We never let VCPUs sleep in no sleep icount mode.
442 * If there is a pending QEMU_CLOCK_VIRTUAL timer we just advance
443 * to the next QEMU_CLOCK_VIRTUAL event and notify it.
444 * It is useful when we want a deterministic execution time,
445 * isolated from host latencies.
447 seqlock_write_lock(&timers_state.vm_clock_seqlock);
448 timers_state.qemu_icount_bias += deadline;
449 seqlock_write_unlock(&timers_state.vm_clock_seqlock);
450 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
451 } else {
453 * We do stop VCPUs and only advance QEMU_CLOCK_VIRTUAL after some
454 * "real" time, (related to the time left until the next event) has
455 * passed. The QEMU_CLOCK_VIRTUAL_RT clock will do this.
456 * This avoids that the warps are visible externally; for example,
457 * you will not be sending network packets continuously instead of
458 * every 100ms.
460 seqlock_write_lock(&timers_state.vm_clock_seqlock);
461 if (vm_clock_warp_start == -1 || vm_clock_warp_start > clock) {
462 vm_clock_warp_start = clock;
464 seqlock_write_unlock(&timers_state.vm_clock_seqlock);
465 timer_mod_anticipate(icount_warp_timer, clock + deadline);
467 } else if (deadline == 0) {
468 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
472 static bool icount_state_needed(void *opaque)
474 return use_icount;
478 * This is a subsection for icount migration.
480 static const VMStateDescription icount_vmstate_timers = {
481 .name = "timer/icount",
482 .version_id = 1,
483 .minimum_version_id = 1,
484 .needed = icount_state_needed,
485 .fields = (VMStateField[]) {
486 VMSTATE_INT64(qemu_icount_bias, TimersState),
487 VMSTATE_INT64(qemu_icount, TimersState),
488 VMSTATE_END_OF_LIST()
492 static const VMStateDescription vmstate_timers = {
493 .name = "timer",
494 .version_id = 2,
495 .minimum_version_id = 1,
496 .fields = (VMStateField[]) {
497 VMSTATE_INT64(cpu_ticks_offset, TimersState),
498 VMSTATE_INT64(dummy, TimersState),
499 VMSTATE_INT64_V(cpu_clock_offset, TimersState, 2),
500 VMSTATE_END_OF_LIST()
502 .subsections = (const VMStateDescription*[]) {
503 &icount_vmstate_timers,
504 NULL
508 void cpu_ticks_init(void)
510 seqlock_init(&timers_state.vm_clock_seqlock, NULL);
511 vmstate_register(NULL, 0, &vmstate_timers, &timers_state);
514 void configure_icount(QemuOpts *opts, Error **errp)
516 const char *option;
517 char *rem_str = NULL;
519 option = qemu_opt_get(opts, "shift");
520 if (!option) {
521 if (qemu_opt_get(opts, "align") != NULL) {
522 error_setg(errp, "Please specify shift option when using align");
524 return;
527 icount_sleep = qemu_opt_get_bool(opts, "sleep", true);
528 if (icount_sleep) {
529 icount_warp_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL_RT,
530 icount_warp_rt, NULL);
533 icount_align_option = qemu_opt_get_bool(opts, "align", false);
535 if (icount_align_option && !icount_sleep) {
536 error_setg(errp, "align=on and sleep=no are incompatible");
538 if (strcmp(option, "auto") != 0) {
539 errno = 0;
540 icount_time_shift = strtol(option, &rem_str, 0);
541 if (errno != 0 || *rem_str != '\0' || !strlen(option)) {
542 error_setg(errp, "icount: Invalid shift value");
544 use_icount = 1;
545 return;
546 } else if (icount_align_option) {
547 error_setg(errp, "shift=auto and align=on are incompatible");
548 } else if (!icount_sleep) {
549 error_setg(errp, "shift=auto and sleep=no are incompatible");
552 use_icount = 2;
554 /* 125MIPS seems a reasonable initial guess at the guest speed.
555 It will be corrected fairly quickly anyway. */
556 icount_time_shift = 3;
558 /* Have both realtime and virtual time triggers for speed adjustment.
559 The realtime trigger catches emulated time passing too slowly,
560 the virtual time trigger catches emulated time passing too fast.
561 Realtime triggers occur even when idle, so use them less frequently
562 than VM triggers. */
563 icount_rt_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL_RT,
564 icount_adjust_rt, NULL);
565 timer_mod(icount_rt_timer,
566 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT) + 1000);
567 icount_vm_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
568 icount_adjust_vm, NULL);
569 timer_mod(icount_vm_timer,
570 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
571 get_ticks_per_sec() / 10);
574 /***********************************************************/
575 void hw_error(const char *fmt, ...)
577 va_list ap;
578 CPUState *cpu;
580 va_start(ap, fmt);
581 fprintf(stderr, "qemu: hardware error: ");
582 vfprintf(stderr, fmt, ap);
583 fprintf(stderr, "\n");
584 CPU_FOREACH(cpu) {
585 fprintf(stderr, "CPU #%d:\n", cpu->cpu_index);
586 cpu_dump_state(cpu, stderr, fprintf, CPU_DUMP_FPU);
588 va_end(ap);
589 abort();
592 void cpu_synchronize_all_states(void)
594 CPUState *cpu;
596 CPU_FOREACH(cpu) {
597 cpu_synchronize_state(cpu);
601 void cpu_synchronize_all_post_reset(void)
603 CPUState *cpu;
605 CPU_FOREACH(cpu) {
606 cpu_synchronize_post_reset(cpu);
610 void cpu_synchronize_all_post_init(void)
612 CPUState *cpu;
614 CPU_FOREACH(cpu) {
615 cpu_synchronize_post_init(cpu);
619 void cpu_clean_all_dirty(void)
621 CPUState *cpu;
623 CPU_FOREACH(cpu) {
624 cpu_clean_state(cpu);
628 static int do_vm_stop(RunState state)
630 int ret = 0;
632 if (runstate_is_running()) {
633 cpu_disable_ticks();
634 pause_all_vcpus();
635 runstate_set(state);
636 vm_state_notify(0, state);
637 qapi_event_send_stop(&error_abort);
640 bdrv_drain_all();
641 ret = bdrv_flush_all();
643 return ret;
646 static bool cpu_can_run(CPUState *cpu)
648 if (cpu->stop) {
649 return false;
651 if (cpu_is_stopped(cpu)) {
652 return false;
654 return true;
657 static void cpu_handle_guest_debug(CPUState *cpu)
659 gdb_set_stop_cpu(cpu);
660 qemu_system_debug_request();
661 cpu->stopped = true;
664 static void cpu_signal(int sig)
666 if (current_cpu) {
667 cpu_exit(current_cpu);
669 exit_request = 1;
672 #ifdef CONFIG_LINUX
673 static void sigbus_reraise(void)
675 sigset_t set;
676 struct sigaction action;
678 memset(&action, 0, sizeof(action));
679 action.sa_handler = SIG_DFL;
680 if (!sigaction(SIGBUS, &action, NULL)) {
681 raise(SIGBUS);
682 sigemptyset(&set);
683 sigaddset(&set, SIGBUS);
684 sigprocmask(SIG_UNBLOCK, &set, NULL);
686 perror("Failed to re-raise SIGBUS!\n");
687 abort();
690 static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo,
691 void *ctx)
693 if (kvm_on_sigbus(siginfo->ssi_code,
694 (void *)(intptr_t)siginfo->ssi_addr)) {
695 sigbus_reraise();
699 static void qemu_init_sigbus(void)
701 struct sigaction action;
703 memset(&action, 0, sizeof(action));
704 action.sa_flags = SA_SIGINFO;
705 action.sa_sigaction = (void (*)(int, siginfo_t*, void*))sigbus_handler;
706 sigaction(SIGBUS, &action, NULL);
708 prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, 0, 0);
711 static void qemu_kvm_eat_signals(CPUState *cpu)
713 struct timespec ts = { 0, 0 };
714 siginfo_t siginfo;
715 sigset_t waitset;
716 sigset_t chkset;
717 int r;
719 sigemptyset(&waitset);
720 sigaddset(&waitset, SIG_IPI);
721 sigaddset(&waitset, SIGBUS);
723 do {
724 r = sigtimedwait(&waitset, &siginfo, &ts);
725 if (r == -1 && !(errno == EAGAIN || errno == EINTR)) {
726 perror("sigtimedwait");
727 exit(1);
730 switch (r) {
731 case SIGBUS:
732 if (kvm_on_sigbus_vcpu(cpu, siginfo.si_code, siginfo.si_addr)) {
733 sigbus_reraise();
735 break;
736 default:
737 break;
740 r = sigpending(&chkset);
741 if (r == -1) {
742 perror("sigpending");
743 exit(1);
745 } while (sigismember(&chkset, SIG_IPI) || sigismember(&chkset, SIGBUS));
748 #else /* !CONFIG_LINUX */
750 static void qemu_init_sigbus(void)
754 static void qemu_kvm_eat_signals(CPUState *cpu)
757 #endif /* !CONFIG_LINUX */
759 #ifndef _WIN32
760 static void dummy_signal(int sig)
764 static void qemu_kvm_init_cpu_signals(CPUState *cpu)
766 int r;
767 sigset_t set;
768 struct sigaction sigact;
770 memset(&sigact, 0, sizeof(sigact));
771 sigact.sa_handler = dummy_signal;
772 sigaction(SIG_IPI, &sigact, NULL);
774 pthread_sigmask(SIG_BLOCK, NULL, &set);
775 sigdelset(&set, SIG_IPI);
776 sigdelset(&set, SIGBUS);
777 r = kvm_set_signal_mask(cpu, &set);
778 if (r) {
779 fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));
780 exit(1);
784 static void qemu_tcg_init_cpu_signals(void)
786 sigset_t set;
787 struct sigaction sigact;
789 memset(&sigact, 0, sizeof(sigact));
790 sigact.sa_handler = cpu_signal;
791 sigaction(SIG_IPI, &sigact, NULL);
793 sigemptyset(&set);
794 sigaddset(&set, SIG_IPI);
795 pthread_sigmask(SIG_UNBLOCK, &set, NULL);
798 #else /* _WIN32 */
799 static void qemu_kvm_init_cpu_signals(CPUState *cpu)
801 abort();
804 static void qemu_tcg_init_cpu_signals(void)
807 #endif /* _WIN32 */
809 static QemuMutex qemu_global_mutex;
810 static QemuCond qemu_io_proceeded_cond;
811 static unsigned iothread_requesting_mutex;
813 static QemuThread io_thread;
815 static QemuThread *tcg_cpu_thread;
816 static QemuCond *tcg_halt_cond;
818 /* cpu creation */
819 static QemuCond qemu_cpu_cond;
820 /* system init */
821 static QemuCond qemu_pause_cond;
822 static QemuCond qemu_work_cond;
824 void qemu_init_cpu_loop(void)
826 qemu_init_sigbus();
827 qemu_cond_init(&qemu_cpu_cond);
828 qemu_cond_init(&qemu_pause_cond);
829 qemu_cond_init(&qemu_work_cond);
830 qemu_cond_init(&qemu_io_proceeded_cond);
831 qemu_mutex_init(&qemu_global_mutex);
833 qemu_thread_get_self(&io_thread);
836 void run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data)
838 struct qemu_work_item wi;
840 if (qemu_cpu_is_self(cpu)) {
841 func(data);
842 return;
845 wi.func = func;
846 wi.data = data;
847 wi.free = false;
848 if (cpu->queued_work_first == NULL) {
849 cpu->queued_work_first = &wi;
850 } else {
851 cpu->queued_work_last->next = &wi;
853 cpu->queued_work_last = &wi;
854 wi.next = NULL;
855 wi.done = false;
857 qemu_cpu_kick(cpu);
858 while (!wi.done) {
859 CPUState *self_cpu = current_cpu;
861 qemu_cond_wait(&qemu_work_cond, &qemu_global_mutex);
862 current_cpu = self_cpu;
866 void async_run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data)
868 struct qemu_work_item *wi;
870 if (qemu_cpu_is_self(cpu)) {
871 func(data);
872 return;
875 wi = g_malloc0(sizeof(struct qemu_work_item));
876 wi->func = func;
877 wi->data = data;
878 wi->free = true;
879 if (cpu->queued_work_first == NULL) {
880 cpu->queued_work_first = wi;
881 } else {
882 cpu->queued_work_last->next = wi;
884 cpu->queued_work_last = wi;
885 wi->next = NULL;
886 wi->done = false;
888 qemu_cpu_kick(cpu);
891 static void flush_queued_work(CPUState *cpu)
893 struct qemu_work_item *wi;
895 if (cpu->queued_work_first == NULL) {
896 return;
899 while ((wi = cpu->queued_work_first)) {
900 cpu->queued_work_first = wi->next;
901 wi->func(wi->data);
902 wi->done = true;
903 if (wi->free) {
904 g_free(wi);
907 cpu->queued_work_last = NULL;
908 qemu_cond_broadcast(&qemu_work_cond);
911 static void qemu_wait_io_event_common(CPUState *cpu)
913 if (cpu->stop) {
914 cpu->stop = false;
915 cpu->stopped = true;
916 qemu_cond_signal(&qemu_pause_cond);
918 flush_queued_work(cpu);
919 cpu->thread_kicked = false;
922 static void qemu_tcg_wait_io_event(void)
924 CPUState *cpu;
926 while (all_cpu_threads_idle()) {
927 /* Start accounting real time to the virtual clock if the CPUs
928 are idle. */
929 qemu_clock_warp(QEMU_CLOCK_VIRTUAL);
930 qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
933 while (iothread_requesting_mutex) {
934 qemu_cond_wait(&qemu_io_proceeded_cond, &qemu_global_mutex);
937 CPU_FOREACH(cpu) {
938 qemu_wait_io_event_common(cpu);
942 static void qemu_kvm_wait_io_event(CPUState *cpu)
944 while (cpu_thread_is_idle(cpu)) {
945 qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
948 qemu_kvm_eat_signals(cpu);
949 qemu_wait_io_event_common(cpu);
952 static void *qemu_kvm_cpu_thread_fn(void *arg)
954 CPUState *cpu = arg;
955 int r;
957 rcu_register_thread();
959 qemu_mutex_lock_iothread();
960 qemu_thread_get_self(cpu->thread);
961 cpu->thread_id = qemu_get_thread_id();
962 cpu->can_do_io = 1;
963 current_cpu = cpu;
965 r = kvm_init_vcpu(cpu);
966 if (r < 0) {
967 fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r));
968 exit(1);
971 qemu_kvm_init_cpu_signals(cpu);
973 /* signal CPU creation */
974 cpu->created = true;
975 qemu_cond_signal(&qemu_cpu_cond);
977 while (1) {
978 if (cpu_can_run(cpu)) {
979 r = kvm_cpu_exec(cpu);
980 if (r == EXCP_DEBUG) {
981 cpu_handle_guest_debug(cpu);
984 qemu_kvm_wait_io_event(cpu);
987 return NULL;
990 static void *qemu_dummy_cpu_thread_fn(void *arg)
992 #ifdef _WIN32
993 fprintf(stderr, "qtest is not supported under Windows\n");
994 exit(1);
995 #else
996 CPUState *cpu = arg;
997 sigset_t waitset;
998 int r;
1000 rcu_register_thread();
1002 qemu_mutex_lock_iothread();
1003 qemu_thread_get_self(cpu->thread);
1004 cpu->thread_id = qemu_get_thread_id();
1005 cpu->can_do_io = 1;
1007 sigemptyset(&waitset);
1008 sigaddset(&waitset, SIG_IPI);
1010 /* signal CPU creation */
1011 cpu->created = true;
1012 qemu_cond_signal(&qemu_cpu_cond);
1014 current_cpu = cpu;
1015 while (1) {
1016 current_cpu = NULL;
1017 qemu_mutex_unlock_iothread();
1018 do {
1019 int sig;
1020 r = sigwait(&waitset, &sig);
1021 } while (r == -1 && (errno == EAGAIN || errno == EINTR));
1022 if (r == -1) {
1023 perror("sigwait");
1024 exit(1);
1026 qemu_mutex_lock_iothread();
1027 current_cpu = cpu;
1028 qemu_wait_io_event_common(cpu);
1031 return NULL;
1032 #endif
1035 static void tcg_exec_all(void);
1037 static void *qemu_tcg_cpu_thread_fn(void *arg)
1039 CPUState *cpu = arg;
1041 rcu_register_thread();
1043 qemu_mutex_lock_iothread();
1044 qemu_tcg_init_cpu_signals();
1045 qemu_thread_get_self(cpu->thread);
1047 CPU_FOREACH(cpu) {
1048 cpu->thread_id = qemu_get_thread_id();
1049 cpu->created = true;
1050 cpu->can_do_io = 1;
1052 qemu_cond_signal(&qemu_cpu_cond);
1054 /* wait for initial kick-off after machine start */
1055 while (first_cpu->stopped) {
1056 qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
1058 /* process any pending work */
1059 CPU_FOREACH(cpu) {
1060 qemu_wait_io_event_common(cpu);
1064 /* process any pending work */
1065 exit_request = 1;
1067 while (1) {
1068 tcg_exec_all();
1070 if (use_icount) {
1071 int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
1073 if (deadline == 0) {
1074 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
1077 qemu_tcg_wait_io_event();
1080 return NULL;
1083 static void qemu_cpu_kick_thread(CPUState *cpu)
1085 #ifndef _WIN32
1086 int err;
1088 err = pthread_kill(cpu->thread->thread, SIG_IPI);
1089 if (err) {
1090 fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
1091 exit(1);
1093 #else /* _WIN32 */
1094 if (!qemu_cpu_is_self(cpu)) {
1095 CONTEXT tcgContext;
1097 if (SuspendThread(cpu->hThread) == (DWORD)-1) {
1098 fprintf(stderr, "qemu:%s: GetLastError:%lu\n", __func__,
1099 GetLastError());
1100 exit(1);
1103 /* On multi-core systems, we are not sure that the thread is actually
1104 * suspended until we can get the context.
1106 tcgContext.ContextFlags = CONTEXT_CONTROL;
1107 while (GetThreadContext(cpu->hThread, &tcgContext) != 0) {
1108 continue;
1111 cpu_signal(0);
1113 if (ResumeThread(cpu->hThread) == (DWORD)-1) {
1114 fprintf(stderr, "qemu:%s: GetLastError:%lu\n", __func__,
1115 GetLastError());
1116 exit(1);
1119 #endif
1122 void qemu_cpu_kick(CPUState *cpu)
1124 qemu_cond_broadcast(cpu->halt_cond);
1125 if (!tcg_enabled() && !cpu->thread_kicked) {
1126 qemu_cpu_kick_thread(cpu);
1127 cpu->thread_kicked = true;
1131 void qemu_cpu_kick_self(void)
1133 #ifndef _WIN32
1134 assert(current_cpu);
1136 if (!current_cpu->thread_kicked) {
1137 qemu_cpu_kick_thread(current_cpu);
1138 current_cpu->thread_kicked = true;
1140 #else
1141 abort();
1142 #endif
1145 bool qemu_cpu_is_self(CPUState *cpu)
1147 return qemu_thread_is_self(cpu->thread);
1150 bool qemu_in_vcpu_thread(void)
1152 return current_cpu && qemu_cpu_is_self(current_cpu);
1155 static __thread bool iothread_locked = false;
1157 bool qemu_mutex_iothread_locked(void)
1159 return iothread_locked;
1162 void qemu_mutex_lock_iothread(void)
1164 atomic_inc(&iothread_requesting_mutex);
1165 /* In the simple case there is no need to bump the VCPU thread out of
1166 * TCG code execution.
1168 if (!tcg_enabled() || qemu_in_vcpu_thread() ||
1169 !first_cpu || !first_cpu->thread) {
1170 qemu_mutex_lock(&qemu_global_mutex);
1171 atomic_dec(&iothread_requesting_mutex);
1172 } else {
1173 if (qemu_mutex_trylock(&qemu_global_mutex)) {
1174 qemu_cpu_kick_thread(first_cpu);
1175 qemu_mutex_lock(&qemu_global_mutex);
1177 atomic_dec(&iothread_requesting_mutex);
1178 qemu_cond_broadcast(&qemu_io_proceeded_cond);
1180 iothread_locked = true;
1183 void qemu_mutex_unlock_iothread(void)
1185 iothread_locked = false;
1186 qemu_mutex_unlock(&qemu_global_mutex);
1189 static int all_vcpus_paused(void)
1191 CPUState *cpu;
1193 CPU_FOREACH(cpu) {
1194 if (!cpu->stopped) {
1195 return 0;
1199 return 1;
1202 void pause_all_vcpus(void)
1204 CPUState *cpu;
1206 qemu_clock_enable(QEMU_CLOCK_VIRTUAL, false);
1207 CPU_FOREACH(cpu) {
1208 cpu->stop = true;
1209 qemu_cpu_kick(cpu);
1212 if (qemu_in_vcpu_thread()) {
1213 cpu_stop_current();
1214 if (!kvm_enabled()) {
1215 CPU_FOREACH(cpu) {
1216 cpu->stop = false;
1217 cpu->stopped = true;
1219 return;
1223 while (!all_vcpus_paused()) {
1224 qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
1225 CPU_FOREACH(cpu) {
1226 qemu_cpu_kick(cpu);
1231 void cpu_resume(CPUState *cpu)
1233 cpu->stop = false;
1234 cpu->stopped = false;
1235 qemu_cpu_kick(cpu);
1238 void resume_all_vcpus(void)
1240 CPUState *cpu;
1242 qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
1243 CPU_FOREACH(cpu) {
1244 cpu_resume(cpu);
1248 /* For temporary buffers for forming a name */
1249 #define VCPU_THREAD_NAME_SIZE 16
1251 static void qemu_tcg_init_vcpu(CPUState *cpu)
1253 char thread_name[VCPU_THREAD_NAME_SIZE];
1255 tcg_cpu_address_space_init(cpu, cpu->as);
1257 /* share a single thread for all cpus with TCG */
1258 if (!tcg_cpu_thread) {
1259 cpu->thread = g_malloc0(sizeof(QemuThread));
1260 cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1261 qemu_cond_init(cpu->halt_cond);
1262 tcg_halt_cond = cpu->halt_cond;
1263 snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/TCG",
1264 cpu->cpu_index);
1265 qemu_thread_create(cpu->thread, thread_name, qemu_tcg_cpu_thread_fn,
1266 cpu, QEMU_THREAD_JOINABLE);
1267 #ifdef _WIN32
1268 cpu->hThread = qemu_thread_get_handle(cpu->thread);
1269 #endif
1270 while (!cpu->created) {
1271 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1273 tcg_cpu_thread = cpu->thread;
1274 } else {
1275 cpu->thread = tcg_cpu_thread;
1276 cpu->halt_cond = tcg_halt_cond;
1280 static void qemu_kvm_start_vcpu(CPUState *cpu)
1282 char thread_name[VCPU_THREAD_NAME_SIZE];
1284 cpu->thread = g_malloc0(sizeof(QemuThread));
1285 cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1286 qemu_cond_init(cpu->halt_cond);
1287 snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/KVM",
1288 cpu->cpu_index);
1289 qemu_thread_create(cpu->thread, thread_name, qemu_kvm_cpu_thread_fn,
1290 cpu, QEMU_THREAD_JOINABLE);
1291 while (!cpu->created) {
1292 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1296 static void qemu_dummy_start_vcpu(CPUState *cpu)
1298 char thread_name[VCPU_THREAD_NAME_SIZE];
1300 cpu->thread = g_malloc0(sizeof(QemuThread));
1301 cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1302 qemu_cond_init(cpu->halt_cond);
1303 snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/DUMMY",
1304 cpu->cpu_index);
1305 qemu_thread_create(cpu->thread, thread_name, qemu_dummy_cpu_thread_fn, cpu,
1306 QEMU_THREAD_JOINABLE);
1307 while (!cpu->created) {
1308 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1312 void qemu_init_vcpu(CPUState *cpu)
1314 cpu->nr_cores = smp_cores;
1315 cpu->nr_threads = smp_threads;
1316 cpu->stopped = true;
1317 if (kvm_enabled()) {
1318 qemu_kvm_start_vcpu(cpu);
1319 } else if (tcg_enabled()) {
1320 qemu_tcg_init_vcpu(cpu);
1321 } else {
1322 qemu_dummy_start_vcpu(cpu);
1326 void cpu_stop_current(void)
1328 if (current_cpu) {
1329 current_cpu->stop = false;
1330 current_cpu->stopped = true;
1331 cpu_exit(current_cpu);
1332 qemu_cond_signal(&qemu_pause_cond);
1336 int vm_stop(RunState state)
1338 if (qemu_in_vcpu_thread()) {
1339 qemu_system_vmstop_request_prepare();
1340 qemu_system_vmstop_request(state);
1342 * FIXME: should not return to device code in case
1343 * vm_stop() has been requested.
1345 cpu_stop_current();
1346 return 0;
1349 return do_vm_stop(state);
1352 /* does a state transition even if the VM is already stopped,
1353 current state is forgotten forever */
1354 int vm_stop_force_state(RunState state)
1356 if (runstate_is_running()) {
1357 return vm_stop(state);
1358 } else {
1359 runstate_set(state);
1360 /* Make sure to return an error if the flush in a previous vm_stop()
1361 * failed. */
1362 return bdrv_flush_all();
1366 static int tcg_cpu_exec(CPUState *cpu)
1368 int ret;
1369 #ifdef CONFIG_PROFILER
1370 int64_t ti;
1371 #endif
1373 #ifdef CONFIG_PROFILER
1374 ti = profile_getclock();
1375 #endif
1376 if (use_icount) {
1377 int64_t count;
1378 int64_t deadline;
1379 int decr;
1380 timers_state.qemu_icount -= (cpu->icount_decr.u16.low
1381 + cpu->icount_extra);
1382 cpu->icount_decr.u16.low = 0;
1383 cpu->icount_extra = 0;
1384 deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
1386 /* Maintain prior (possibly buggy) behaviour where if no deadline
1387 * was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than
1388 * INT32_MAX nanoseconds ahead, we still use INT32_MAX
1389 * nanoseconds.
1391 if ((deadline < 0) || (deadline > INT32_MAX)) {
1392 deadline = INT32_MAX;
1395 count = qemu_icount_round(deadline);
1396 timers_state.qemu_icount += count;
1397 decr = (count > 0xffff) ? 0xffff : count;
1398 count -= decr;
1399 cpu->icount_decr.u16.low = decr;
1400 cpu->icount_extra = count;
1402 ret = cpu_exec(cpu);
1403 #ifdef CONFIG_PROFILER
1404 tcg_time += profile_getclock() - ti;
1405 #endif
1406 if (use_icount) {
1407 /* Fold pending instructions back into the
1408 instruction counter, and clear the interrupt flag. */
1409 timers_state.qemu_icount -= (cpu->icount_decr.u16.low
1410 + cpu->icount_extra);
1411 cpu->icount_decr.u32 = 0;
1412 cpu->icount_extra = 0;
1414 return ret;
1417 static void tcg_exec_all(void)
1419 int r;
1421 /* Account partial waits to QEMU_CLOCK_VIRTUAL. */
1422 qemu_clock_warp(QEMU_CLOCK_VIRTUAL);
1424 if (next_cpu == NULL) {
1425 next_cpu = first_cpu;
1427 for (; next_cpu != NULL && !exit_request; next_cpu = CPU_NEXT(next_cpu)) {
1428 CPUState *cpu = next_cpu;
1430 qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
1431 (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);
1433 if (cpu_can_run(cpu)) {
1434 r = tcg_cpu_exec(cpu);
1435 if (r == EXCP_DEBUG) {
1436 cpu_handle_guest_debug(cpu);
1437 break;
1439 } else if (cpu->stop || cpu->stopped) {
1440 break;
1443 exit_request = 0;
1446 void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
1448 /* XXX: implement xxx_cpu_list for targets that still miss it */
1449 #if defined(cpu_list)
1450 cpu_list(f, cpu_fprintf);
1451 #endif
1454 CpuInfoList *qmp_query_cpus(Error **errp)
1456 CpuInfoList *head = NULL, *cur_item = NULL;
1457 CPUState *cpu;
1459 CPU_FOREACH(cpu) {
1460 CpuInfoList *info;
1461 #if defined(TARGET_I386)
1462 X86CPU *x86_cpu = X86_CPU(cpu);
1463 CPUX86State *env = &x86_cpu->env;
1464 #elif defined(TARGET_PPC)
1465 PowerPCCPU *ppc_cpu = POWERPC_CPU(cpu);
1466 CPUPPCState *env = &ppc_cpu->env;
1467 #elif defined(TARGET_SPARC)
1468 SPARCCPU *sparc_cpu = SPARC_CPU(cpu);
1469 CPUSPARCState *env = &sparc_cpu->env;
1470 #elif defined(TARGET_MIPS)
1471 MIPSCPU *mips_cpu = MIPS_CPU(cpu);
1472 CPUMIPSState *env = &mips_cpu->env;
1473 #elif defined(TARGET_TRICORE)
1474 TriCoreCPU *tricore_cpu = TRICORE_CPU(cpu);
1475 CPUTriCoreState *env = &tricore_cpu->env;
1476 #endif
1478 cpu_synchronize_state(cpu);
1480 info = g_malloc0(sizeof(*info));
1481 info->value = g_malloc0(sizeof(*info->value));
1482 info->value->CPU = cpu->cpu_index;
1483 info->value->current = (cpu == first_cpu);
1484 info->value->halted = cpu->halted;
1485 info->value->qom_path = object_get_canonical_path(OBJECT(cpu));
1486 info->value->thread_id = cpu->thread_id;
1487 #if defined(TARGET_I386)
1488 info->value->has_pc = true;
1489 info->value->pc = env->eip + env->segs[R_CS].base;
1490 #elif defined(TARGET_PPC)
1491 info->value->has_nip = true;
1492 info->value->nip = env->nip;
1493 #elif defined(TARGET_SPARC)
1494 info->value->has_pc = true;
1495 info->value->pc = env->pc;
1496 info->value->has_npc = true;
1497 info->value->npc = env->npc;
1498 #elif defined(TARGET_MIPS)
1499 info->value->has_PC = true;
1500 info->value->PC = env->active_tc.PC;
1501 #elif defined(TARGET_TRICORE)
1502 info->value->has_PC = true;
1503 info->value->PC = env->PC;
1504 #endif
1506 /* XXX: waiting for the qapi to support GSList */
1507 if (!cur_item) {
1508 head = cur_item = info;
1509 } else {
1510 cur_item->next = info;
1511 cur_item = info;
1515 return head;
1518 void qmp_memsave(int64_t addr, int64_t size, const char *filename,
1519 bool has_cpu, int64_t cpu_index, Error **errp)
1521 FILE *f;
1522 uint32_t l;
1523 CPUState *cpu;
1524 uint8_t buf[1024];
1525 int64_t orig_addr = addr, orig_size = size;
1527 if (!has_cpu) {
1528 cpu_index = 0;
1531 cpu = qemu_get_cpu(cpu_index);
1532 if (cpu == NULL) {
1533 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
1534 "a CPU number");
1535 return;
1538 f = fopen(filename, "wb");
1539 if (!f) {
1540 error_setg_file_open(errp, errno, filename);
1541 return;
1544 while (size != 0) {
1545 l = sizeof(buf);
1546 if (l > size)
1547 l = size;
1548 if (cpu_memory_rw_debug(cpu, addr, buf, l, 0) != 0) {
1549 error_setg(errp, "Invalid addr 0x%016" PRIx64 "/size %" PRId64
1550 " specified", orig_addr, orig_size);
1551 goto exit;
1553 if (fwrite(buf, 1, l, f) != l) {
1554 error_setg(errp, QERR_IO_ERROR);
1555 goto exit;
1557 addr += l;
1558 size -= l;
1561 exit:
1562 fclose(f);
1565 void qmp_pmemsave(int64_t addr, int64_t size, const char *filename,
1566 Error **errp)
1568 FILE *f;
1569 uint32_t l;
1570 uint8_t buf[1024];
1572 f = fopen(filename, "wb");
1573 if (!f) {
1574 error_setg_file_open(errp, errno, filename);
1575 return;
1578 while (size != 0) {
1579 l = sizeof(buf);
1580 if (l > size)
1581 l = size;
1582 cpu_physical_memory_read(addr, buf, l);
1583 if (fwrite(buf, 1, l, f) != l) {
1584 error_setg(errp, QERR_IO_ERROR);
1585 goto exit;
1587 addr += l;
1588 size -= l;
1591 exit:
1592 fclose(f);
1595 void qmp_inject_nmi(Error **errp)
1597 #if defined(TARGET_I386)
1598 CPUState *cs;
1600 CPU_FOREACH(cs) {
1601 X86CPU *cpu = X86_CPU(cs);
1603 if (!cpu->apic_state) {
1604 cpu_interrupt(cs, CPU_INTERRUPT_NMI);
1605 } else {
1606 apic_deliver_nmi(cpu->apic_state);
1609 #else
1610 nmi_monitor_handle(monitor_get_cpu_index(), errp);
1611 #endif
1614 void dump_drift_info(FILE *f, fprintf_function cpu_fprintf)
1616 if (!use_icount) {
1617 return;
1620 cpu_fprintf(f, "Host - Guest clock %"PRIi64" ms\n",
1621 (cpu_get_clock() - cpu_get_icount())/SCALE_MS);
1622 if (icount_align_option) {
1623 cpu_fprintf(f, "Max guest delay %"PRIi64" ms\n", -max_delay/SCALE_MS);
1624 cpu_fprintf(f, "Max guest advance %"PRIi64" ms\n", max_advance/SCALE_MS);
1625 } else {
1626 cpu_fprintf(f, "Max guest delay NA\n");
1627 cpu_fprintf(f, "Max guest advance NA\n");