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
25 /* Needed early for CONFIG_BSD etc. */
26 #include "qemu/osdep.h"
27 #include "qemu-common.h"
28 #include "qemu/config-file.h"
30 #include "monitor/monitor.h"
31 #include "qapi/qmp/qerror.h"
32 #include "qemu/error-report.h"
33 #include "sysemu/sysemu.h"
34 #include "sysemu/block-backend.h"
35 #include "exec/gdbstub.h"
36 #include "sysemu/dma.h"
37 #include "sysemu/hw_accel.h"
38 #include "sysemu/kvm.h"
39 #include "sysemu/hax.h"
40 #include "qmp-commands.h"
41 #include "exec/exec-all.h"
43 #include "qemu/thread.h"
44 #include "sysemu/cpus.h"
45 #include "sysemu/qtest.h"
46 #include "qemu/main-loop.h"
47 #include "qemu/bitmap.h"
48 #include "qemu/seqlock.h"
50 #include "qapi-event.h"
52 #include "sysemu/replay.h"
56 #include <sys/prctl.h>
59 #define PR_MCE_KILL 33
62 #ifndef PR_MCE_KILL_SET
63 #define PR_MCE_KILL_SET 1
66 #ifndef PR_MCE_KILL_EARLY
67 #define PR_MCE_KILL_EARLY 1
70 #endif /* CONFIG_LINUX */
75 /* vcpu throttling controls */
76 static QEMUTimer
*throttle_timer
;
77 static unsigned int throttle_percentage
;
79 #define CPU_THROTTLE_PCT_MIN 1
80 #define CPU_THROTTLE_PCT_MAX 99
81 #define CPU_THROTTLE_TIMESLICE_NS 10000000
83 bool cpu_is_stopped(CPUState
*cpu
)
85 return cpu
->stopped
|| !runstate_is_running();
88 static bool cpu_thread_is_idle(CPUState
*cpu
)
90 if (cpu
->stop
|| cpu
->queued_work_first
) {
93 if (cpu_is_stopped(cpu
)) {
96 if (!cpu
->halted
|| cpu_has_work(cpu
) ||
97 kvm_halt_in_kernel()) {
103 static bool all_cpu_threads_idle(void)
108 if (!cpu_thread_is_idle(cpu
)) {
115 /***********************************************************/
116 /* guest cycle counter */
118 /* Protected by TimersState seqlock */
120 static bool icount_sleep
= true;
121 static int64_t vm_clock_warp_start
= -1;
122 /* Conversion factor from emulated instructions to virtual clock ticks. */
123 static int icount_time_shift
;
124 /* Arbitrarily pick 1MIPS as the minimum allowable speed. */
125 #define MAX_ICOUNT_SHIFT 10
127 static QEMUTimer
*icount_rt_timer
;
128 static QEMUTimer
*icount_vm_timer
;
129 static QEMUTimer
*icount_warp_timer
;
131 typedef struct TimersState
{
132 /* Protected by BQL. */
133 int64_t cpu_ticks_prev
;
134 int64_t cpu_ticks_offset
;
136 /* cpu_clock_offset can be read out of BQL, so protect it with
139 QemuSeqLock vm_clock_seqlock
;
140 int64_t cpu_clock_offset
;
141 int32_t cpu_ticks_enabled
;
144 /* Compensate for varying guest execution speed. */
145 int64_t qemu_icount_bias
;
146 /* Only written by TCG thread */
150 static TimersState timers_state
;
154 * We default to false if we know other options have been enabled
155 * which are currently incompatible with MTTCG. Otherwise when each
156 * guest (target) has been updated to support:
157 * - atomic instructions
158 * - memory ordering primitives (barriers)
159 * they can set the appropriate CONFIG flags in ${target}-softmmu.mak
161 * Once a guest architecture has been converted to the new primitives
162 * there are two remaining limitations to check.
164 * - The guest can't be oversized (e.g. 64 bit guest on 32 bit host)
165 * - The host must have a stronger memory order than the guest
167 * It may be possible in future to support strong guests on weak hosts
168 * but that will require tagging all load/stores in a guest with their
169 * implicit memory order requirements which would likely slow things
173 static bool check_tcg_memory_orders_compatible(void)
175 #if defined(TCG_GUEST_DEFAULT_MO) && defined(TCG_TARGET_DEFAULT_MO)
176 return (TCG_GUEST_DEFAULT_MO
& ~TCG_TARGET_DEFAULT_MO
) == 0;
182 static bool default_mttcg_enabled(void)
184 if (use_icount
|| TCG_OVERSIZED_GUEST
) {
187 #ifdef TARGET_SUPPORTS_MTTCG
188 return check_tcg_memory_orders_compatible();
195 void qemu_tcg_configure(QemuOpts
*opts
, Error
**errp
)
197 const char *t
= qemu_opt_get(opts
, "thread");
199 if (strcmp(t
, "multi") == 0) {
200 if (TCG_OVERSIZED_GUEST
) {
201 error_setg(errp
, "No MTTCG when guest word size > hosts");
202 } else if (use_icount
) {
203 error_setg(errp
, "No MTTCG when icount is enabled");
205 #ifndef TARGET_SUPPORT_MTTCG
206 error_report("Guest not yet converted to MTTCG - "
207 "you may get unexpected results");
209 if (!check_tcg_memory_orders_compatible()) {
210 error_report("Guest expects a stronger memory ordering "
211 "than the host provides");
212 error_printf("This may cause strange/hard to debug errors");
214 mttcg_enabled
= true;
216 } else if (strcmp(t
, "single") == 0) {
217 mttcg_enabled
= false;
219 error_setg(errp
, "Invalid 'thread' setting %s", t
);
222 mttcg_enabled
= default_mttcg_enabled();
226 int64_t cpu_get_icount_raw(void)
229 CPUState
*cpu
= current_cpu
;
231 icount
= timers_state
.qemu_icount
;
233 if (!cpu
->can_do_io
) {
234 fprintf(stderr
, "Bad icount read\n");
237 icount
-= (cpu
->icount_decr
.u16
.low
+ cpu
->icount_extra
);
242 /* Return the virtual CPU time, based on the instruction counter. */
243 static int64_t cpu_get_icount_locked(void)
245 int64_t icount
= cpu_get_icount_raw();
246 return timers_state
.qemu_icount_bias
+ cpu_icount_to_ns(icount
);
249 int64_t cpu_get_icount(void)
255 start
= seqlock_read_begin(&timers_state
.vm_clock_seqlock
);
256 icount
= cpu_get_icount_locked();
257 } while (seqlock_read_retry(&timers_state
.vm_clock_seqlock
, start
));
262 int64_t cpu_icount_to_ns(int64_t icount
)
264 return icount
<< icount_time_shift
;
267 /* return the time elapsed in VM between vm_start and vm_stop. Unless
268 * icount is active, cpu_get_ticks() uses units of the host CPU cycle
271 * Caller must hold the BQL
273 int64_t cpu_get_ticks(void)
278 return cpu_get_icount();
281 ticks
= timers_state
.cpu_ticks_offset
;
282 if (timers_state
.cpu_ticks_enabled
) {
283 ticks
+= cpu_get_host_ticks();
286 if (timers_state
.cpu_ticks_prev
> ticks
) {
287 /* Note: non increasing ticks may happen if the host uses
289 timers_state
.cpu_ticks_offset
+= timers_state
.cpu_ticks_prev
- ticks
;
290 ticks
= timers_state
.cpu_ticks_prev
;
293 timers_state
.cpu_ticks_prev
= ticks
;
297 static int64_t cpu_get_clock_locked(void)
301 time
= timers_state
.cpu_clock_offset
;
302 if (timers_state
.cpu_ticks_enabled
) {
309 /* Return the monotonic time elapsed in VM, i.e.,
310 * the time between vm_start and vm_stop
312 int64_t cpu_get_clock(void)
318 start
= seqlock_read_begin(&timers_state
.vm_clock_seqlock
);
319 ti
= cpu_get_clock_locked();
320 } while (seqlock_read_retry(&timers_state
.vm_clock_seqlock
, start
));
325 /* enable cpu_get_ticks()
326 * Caller must hold BQL which serves as mutex for vm_clock_seqlock.
328 void cpu_enable_ticks(void)
330 /* Here, the really thing protected by seqlock is cpu_clock_offset. */
331 seqlock_write_begin(&timers_state
.vm_clock_seqlock
);
332 if (!timers_state
.cpu_ticks_enabled
) {
333 timers_state
.cpu_ticks_offset
-= cpu_get_host_ticks();
334 timers_state
.cpu_clock_offset
-= get_clock();
335 timers_state
.cpu_ticks_enabled
= 1;
337 seqlock_write_end(&timers_state
.vm_clock_seqlock
);
340 /* disable cpu_get_ticks() : the clock is stopped. You must not call
341 * cpu_get_ticks() after that.
342 * Caller must hold BQL which serves as mutex for vm_clock_seqlock.
344 void cpu_disable_ticks(void)
346 /* Here, the really thing protected by seqlock is cpu_clock_offset. */
347 seqlock_write_begin(&timers_state
.vm_clock_seqlock
);
348 if (timers_state
.cpu_ticks_enabled
) {
349 timers_state
.cpu_ticks_offset
+= cpu_get_host_ticks();
350 timers_state
.cpu_clock_offset
= cpu_get_clock_locked();
351 timers_state
.cpu_ticks_enabled
= 0;
353 seqlock_write_end(&timers_state
.vm_clock_seqlock
);
356 /* Correlation between real and virtual time is always going to be
357 fairly approximate, so ignore small variation.
358 When the guest is idle real and virtual time will be aligned in
360 #define ICOUNT_WOBBLE (NANOSECONDS_PER_SECOND / 10)
362 static void icount_adjust(void)
368 /* Protected by TimersState mutex. */
369 static int64_t last_delta
;
371 /* If the VM is not running, then do nothing. */
372 if (!runstate_is_running()) {
376 seqlock_write_begin(&timers_state
.vm_clock_seqlock
);
377 cur_time
= cpu_get_clock_locked();
378 cur_icount
= cpu_get_icount_locked();
380 delta
= cur_icount
- cur_time
;
381 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
383 && last_delta
+ ICOUNT_WOBBLE
< delta
* 2
384 && icount_time_shift
> 0) {
385 /* The guest is getting too far ahead. Slow time down. */
389 && last_delta
- ICOUNT_WOBBLE
> delta
* 2
390 && icount_time_shift
< MAX_ICOUNT_SHIFT
) {
391 /* The guest is getting too far behind. Speed time up. */
395 timers_state
.qemu_icount_bias
= cur_icount
396 - (timers_state
.qemu_icount
<< icount_time_shift
);
397 seqlock_write_end(&timers_state
.vm_clock_seqlock
);
400 static void icount_adjust_rt(void *opaque
)
402 timer_mod(icount_rt_timer
,
403 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT
) + 1000);
407 static void icount_adjust_vm(void *opaque
)
409 timer_mod(icount_vm_timer
,
410 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) +
411 NANOSECONDS_PER_SECOND
/ 10);
415 static int64_t qemu_icount_round(int64_t count
)
417 return (count
+ (1 << icount_time_shift
) - 1) >> icount_time_shift
;
420 static void icount_warp_rt(void)
425 /* The icount_warp_timer is rescheduled soon after vm_clock_warp_start
426 * changes from -1 to another value, so the race here is okay.
429 seq
= seqlock_read_begin(&timers_state
.vm_clock_seqlock
);
430 warp_start
= vm_clock_warp_start
;
431 } while (seqlock_read_retry(&timers_state
.vm_clock_seqlock
, seq
));
433 if (warp_start
== -1) {
437 seqlock_write_begin(&timers_state
.vm_clock_seqlock
);
438 if (runstate_is_running()) {
439 int64_t clock
= REPLAY_CLOCK(REPLAY_CLOCK_VIRTUAL_RT
,
440 cpu_get_clock_locked());
443 warp_delta
= clock
- vm_clock_warp_start
;
444 if (use_icount
== 2) {
446 * In adaptive mode, do not let QEMU_CLOCK_VIRTUAL run too
447 * far ahead of real time.
449 int64_t cur_icount
= cpu_get_icount_locked();
450 int64_t delta
= clock
- cur_icount
;
451 warp_delta
= MIN(warp_delta
, delta
);
453 timers_state
.qemu_icount_bias
+= warp_delta
;
455 vm_clock_warp_start
= -1;
456 seqlock_write_end(&timers_state
.vm_clock_seqlock
);
458 if (qemu_clock_expired(QEMU_CLOCK_VIRTUAL
)) {
459 qemu_clock_notify(QEMU_CLOCK_VIRTUAL
);
463 static void icount_timer_cb(void *opaque
)
465 /* No need for a checkpoint because the timer already synchronizes
466 * with CHECKPOINT_CLOCK_VIRTUAL_RT.
471 void qtest_clock_warp(int64_t dest
)
473 int64_t clock
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
474 AioContext
*aio_context
;
475 assert(qtest_enabled());
476 aio_context
= qemu_get_aio_context();
477 while (clock
< dest
) {
478 int64_t deadline
= qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL
);
479 int64_t warp
= qemu_soonest_timeout(dest
- clock
, deadline
);
481 seqlock_write_begin(&timers_state
.vm_clock_seqlock
);
482 timers_state
.qemu_icount_bias
+= warp
;
483 seqlock_write_end(&timers_state
.vm_clock_seqlock
);
485 qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL
);
486 timerlist_run_timers(aio_context
->tlg
.tl
[QEMU_CLOCK_VIRTUAL
]);
487 clock
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
489 qemu_clock_notify(QEMU_CLOCK_VIRTUAL
);
492 void qemu_start_warp_timer(void)
501 /* Nothing to do if the VM is stopped: QEMU_CLOCK_VIRTUAL timers
502 * do not fire, so computing the deadline does not make sense.
504 if (!runstate_is_running()) {
508 /* warp clock deterministically in record/replay mode */
509 if (!replay_checkpoint(CHECKPOINT_CLOCK_WARP_START
)) {
513 if (!all_cpu_threads_idle()) {
517 if (qtest_enabled()) {
518 /* When testing, qtest commands advance icount. */
522 /* We want to use the earliest deadline from ALL vm_clocks */
523 clock
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT
);
524 deadline
= qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL
);
526 static bool notified
;
527 if (!icount_sleep
&& !notified
) {
528 error_report("WARNING: icount sleep disabled and no active timers");
536 * Ensure QEMU_CLOCK_VIRTUAL proceeds even when the virtual CPU goes to
537 * sleep. Otherwise, the CPU might be waiting for a future timer
538 * interrupt to wake it up, but the interrupt never comes because
539 * the vCPU isn't running any insns and thus doesn't advance the
540 * QEMU_CLOCK_VIRTUAL.
544 * We never let VCPUs sleep in no sleep icount mode.
545 * If there is a pending QEMU_CLOCK_VIRTUAL timer we just advance
546 * to the next QEMU_CLOCK_VIRTUAL event and notify it.
547 * It is useful when we want a deterministic execution time,
548 * isolated from host latencies.
550 seqlock_write_begin(&timers_state
.vm_clock_seqlock
);
551 timers_state
.qemu_icount_bias
+= deadline
;
552 seqlock_write_end(&timers_state
.vm_clock_seqlock
);
553 qemu_clock_notify(QEMU_CLOCK_VIRTUAL
);
556 * We do stop VCPUs and only advance QEMU_CLOCK_VIRTUAL after some
557 * "real" time, (related to the time left until the next event) has
558 * passed. The QEMU_CLOCK_VIRTUAL_RT clock will do this.
559 * This avoids that the warps are visible externally; for example,
560 * you will not be sending network packets continuously instead of
563 seqlock_write_begin(&timers_state
.vm_clock_seqlock
);
564 if (vm_clock_warp_start
== -1 || vm_clock_warp_start
> clock
) {
565 vm_clock_warp_start
= clock
;
567 seqlock_write_end(&timers_state
.vm_clock_seqlock
);
568 timer_mod_anticipate(icount_warp_timer
, clock
+ deadline
);
570 } else if (deadline
== 0) {
571 qemu_clock_notify(QEMU_CLOCK_VIRTUAL
);
575 static void qemu_account_warp_timer(void)
577 if (!use_icount
|| !icount_sleep
) {
581 /* Nothing to do if the VM is stopped: QEMU_CLOCK_VIRTUAL timers
582 * do not fire, so computing the deadline does not make sense.
584 if (!runstate_is_running()) {
588 /* warp clock deterministically in record/replay mode */
589 if (!replay_checkpoint(CHECKPOINT_CLOCK_WARP_ACCOUNT
)) {
593 timer_del(icount_warp_timer
);
597 static bool icount_state_needed(void *opaque
)
603 * This is a subsection for icount migration.
605 static const VMStateDescription icount_vmstate_timers
= {
606 .name
= "timer/icount",
608 .minimum_version_id
= 1,
609 .needed
= icount_state_needed
,
610 .fields
= (VMStateField
[]) {
611 VMSTATE_INT64(qemu_icount_bias
, TimersState
),
612 VMSTATE_INT64(qemu_icount
, TimersState
),
613 VMSTATE_END_OF_LIST()
617 static const VMStateDescription vmstate_timers
= {
620 .minimum_version_id
= 1,
621 .fields
= (VMStateField
[]) {
622 VMSTATE_INT64(cpu_ticks_offset
, TimersState
),
623 VMSTATE_INT64(dummy
, TimersState
),
624 VMSTATE_INT64_V(cpu_clock_offset
, TimersState
, 2),
625 VMSTATE_END_OF_LIST()
627 .subsections
= (const VMStateDescription
*[]) {
628 &icount_vmstate_timers
,
633 static void cpu_throttle_thread(CPUState
*cpu
, run_on_cpu_data opaque
)
636 double throttle_ratio
;
639 if (!cpu_throttle_get_percentage()) {
643 pct
= (double)cpu_throttle_get_percentage()/100;
644 throttle_ratio
= pct
/ (1 - pct
);
645 sleeptime_ns
= (long)(throttle_ratio
* CPU_THROTTLE_TIMESLICE_NS
);
647 qemu_mutex_unlock_iothread();
648 atomic_set(&cpu
->throttle_thread_scheduled
, 0);
649 g_usleep(sleeptime_ns
/ 1000); /* Convert ns to us for usleep call */
650 qemu_mutex_lock_iothread();
653 static void cpu_throttle_timer_tick(void *opaque
)
658 /* Stop the timer if needed */
659 if (!cpu_throttle_get_percentage()) {
663 if (!atomic_xchg(&cpu
->throttle_thread_scheduled
, 1)) {
664 async_run_on_cpu(cpu
, cpu_throttle_thread
,
669 pct
= (double)cpu_throttle_get_percentage()/100;
670 timer_mod(throttle_timer
, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT
) +
671 CPU_THROTTLE_TIMESLICE_NS
/ (1-pct
));
674 void cpu_throttle_set(int new_throttle_pct
)
676 /* Ensure throttle percentage is within valid range */
677 new_throttle_pct
= MIN(new_throttle_pct
, CPU_THROTTLE_PCT_MAX
);
678 new_throttle_pct
= MAX(new_throttle_pct
, CPU_THROTTLE_PCT_MIN
);
680 atomic_set(&throttle_percentage
, new_throttle_pct
);
682 timer_mod(throttle_timer
, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT
) +
683 CPU_THROTTLE_TIMESLICE_NS
);
686 void cpu_throttle_stop(void)
688 atomic_set(&throttle_percentage
, 0);
691 bool cpu_throttle_active(void)
693 return (cpu_throttle_get_percentage() != 0);
696 int cpu_throttle_get_percentage(void)
698 return atomic_read(&throttle_percentage
);
701 void cpu_ticks_init(void)
703 seqlock_init(&timers_state
.vm_clock_seqlock
);
704 vmstate_register(NULL
, 0, &vmstate_timers
, &timers_state
);
705 throttle_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL_RT
,
706 cpu_throttle_timer_tick
, NULL
);
709 void configure_icount(QemuOpts
*opts
, Error
**errp
)
712 char *rem_str
= NULL
;
714 option
= qemu_opt_get(opts
, "shift");
716 if (qemu_opt_get(opts
, "align") != NULL
) {
717 error_setg(errp
, "Please specify shift option when using align");
722 icount_sleep
= qemu_opt_get_bool(opts
, "sleep", true);
724 icount_warp_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL_RT
,
725 icount_timer_cb
, NULL
);
728 icount_align_option
= qemu_opt_get_bool(opts
, "align", false);
730 if (icount_align_option
&& !icount_sleep
) {
731 error_setg(errp
, "align=on and sleep=off are incompatible");
733 if (strcmp(option
, "auto") != 0) {
735 icount_time_shift
= strtol(option
, &rem_str
, 0);
736 if (errno
!= 0 || *rem_str
!= '\0' || !strlen(option
)) {
737 error_setg(errp
, "icount: Invalid shift value");
741 } else if (icount_align_option
) {
742 error_setg(errp
, "shift=auto and align=on are incompatible");
743 } else if (!icount_sleep
) {
744 error_setg(errp
, "shift=auto and sleep=off are incompatible");
749 /* 125MIPS seems a reasonable initial guess at the guest speed.
750 It will be corrected fairly quickly anyway. */
751 icount_time_shift
= 3;
753 /* Have both realtime and virtual time triggers for speed adjustment.
754 The realtime trigger catches emulated time passing too slowly,
755 the virtual time trigger catches emulated time passing too fast.
756 Realtime triggers occur even when idle, so use them less frequently
758 icount_rt_timer
= timer_new_ms(QEMU_CLOCK_VIRTUAL_RT
,
759 icount_adjust_rt
, NULL
);
760 timer_mod(icount_rt_timer
,
761 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT
) + 1000);
762 icount_vm_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
,
763 icount_adjust_vm
, NULL
);
764 timer_mod(icount_vm_timer
,
765 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) +
766 NANOSECONDS_PER_SECOND
/ 10);
769 /***********************************************************/
770 /* TCG vCPU kick timer
772 * The kick timer is responsible for moving single threaded vCPU
773 * emulation on to the next vCPU. If more than one vCPU is running a
774 * timer event with force a cpu->exit so the next vCPU can get
777 * The timer is removed if all vCPUs are idle and restarted again once
778 * idleness is complete.
781 static QEMUTimer
*tcg_kick_vcpu_timer
;
782 static CPUState
*tcg_current_rr_cpu
;
784 #define TCG_KICK_PERIOD (NANOSECONDS_PER_SECOND / 10)
786 static inline int64_t qemu_tcg_next_kick(void)
788 return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) + TCG_KICK_PERIOD
;
791 /* Kick the currently round-robin scheduled vCPU */
792 static void qemu_cpu_kick_rr_cpu(void)
796 cpu
= atomic_mb_read(&tcg_current_rr_cpu
);
800 } while (cpu
!= atomic_mb_read(&tcg_current_rr_cpu
));
803 void qemu_timer_notify_cb(void *opaque
, QEMUClockType type
)
808 static void kick_tcg_thread(void *opaque
)
810 timer_mod(tcg_kick_vcpu_timer
, qemu_tcg_next_kick());
811 qemu_cpu_kick_rr_cpu();
814 static void start_tcg_kick_timer(void)
816 if (!mttcg_enabled
&& !tcg_kick_vcpu_timer
&& CPU_NEXT(first_cpu
)) {
817 tcg_kick_vcpu_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
,
818 kick_tcg_thread
, NULL
);
819 timer_mod(tcg_kick_vcpu_timer
, qemu_tcg_next_kick());
823 static void stop_tcg_kick_timer(void)
825 if (tcg_kick_vcpu_timer
) {
826 timer_del(tcg_kick_vcpu_timer
);
827 tcg_kick_vcpu_timer
= NULL
;
831 /***********************************************************/
832 void hw_error(const char *fmt
, ...)
838 fprintf(stderr
, "qemu: hardware error: ");
839 vfprintf(stderr
, fmt
, ap
);
840 fprintf(stderr
, "\n");
842 fprintf(stderr
, "CPU #%d:\n", cpu
->cpu_index
);
843 cpu_dump_state(cpu
, stderr
, fprintf
, CPU_DUMP_FPU
);
849 void cpu_synchronize_all_states(void)
854 cpu_synchronize_state(cpu
);
858 void cpu_synchronize_all_post_reset(void)
863 cpu_synchronize_post_reset(cpu
);
867 void cpu_synchronize_all_post_init(void)
872 cpu_synchronize_post_init(cpu
);
876 static int do_vm_stop(RunState state
)
880 if (runstate_is_running()) {
884 vm_state_notify(0, state
);
885 qapi_event_send_stop(&error_abort
);
889 replay_disable_events();
890 ret
= bdrv_flush_all();
895 static bool cpu_can_run(CPUState
*cpu
)
900 if (cpu_is_stopped(cpu
)) {
906 static void cpu_handle_guest_debug(CPUState
*cpu
)
908 gdb_set_stop_cpu(cpu
);
909 qemu_system_debug_request();
914 static void sigbus_reraise(void)
917 struct sigaction action
;
919 memset(&action
, 0, sizeof(action
));
920 action
.sa_handler
= SIG_DFL
;
921 if (!sigaction(SIGBUS
, &action
, NULL
)) {
924 sigaddset(&set
, SIGBUS
);
925 pthread_sigmask(SIG_UNBLOCK
, &set
, NULL
);
927 perror("Failed to re-raise SIGBUS!\n");
931 static void sigbus_handler(int n
, siginfo_t
*siginfo
, void *ctx
)
933 if (siginfo
->si_code
!= BUS_MCEERR_AO
&& siginfo
->si_code
!= BUS_MCEERR_AR
) {
938 /* Called asynchronously in VCPU thread. */
939 if (kvm_on_sigbus_vcpu(current_cpu
, siginfo
->si_code
, siginfo
->si_addr
)) {
943 /* Called synchronously (via signalfd) in main thread. */
944 if (kvm_on_sigbus(siginfo
->si_code
, siginfo
->si_addr
)) {
950 static void qemu_init_sigbus(void)
952 struct sigaction action
;
954 memset(&action
, 0, sizeof(action
));
955 action
.sa_flags
= SA_SIGINFO
;
956 action
.sa_sigaction
= sigbus_handler
;
957 sigaction(SIGBUS
, &action
, NULL
);
959 prctl(PR_MCE_KILL
, PR_MCE_KILL_SET
, PR_MCE_KILL_EARLY
, 0, 0);
961 #else /* !CONFIG_LINUX */
962 static void qemu_init_sigbus(void)
965 #endif /* !CONFIG_LINUX */
967 static QemuMutex qemu_global_mutex
;
969 static QemuThread io_thread
;
972 static QemuCond qemu_cpu_cond
;
974 static QemuCond qemu_pause_cond
;
976 void qemu_init_cpu_loop(void)
979 qemu_cond_init(&qemu_cpu_cond
);
980 qemu_cond_init(&qemu_pause_cond
);
981 qemu_mutex_init(&qemu_global_mutex
);
983 qemu_thread_get_self(&io_thread
);
986 void run_on_cpu(CPUState
*cpu
, run_on_cpu_func func
, run_on_cpu_data data
)
988 do_run_on_cpu(cpu
, func
, data
, &qemu_global_mutex
);
991 static void qemu_kvm_destroy_vcpu(CPUState
*cpu
)
993 if (kvm_destroy_vcpu(cpu
) < 0) {
994 error_report("kvm_destroy_vcpu failed");
999 static void qemu_tcg_destroy_vcpu(CPUState
*cpu
)
1003 static void qemu_wait_io_event_common(CPUState
*cpu
)
1005 atomic_mb_set(&cpu
->thread_kicked
, false);
1008 cpu
->stopped
= true;
1009 qemu_cond_broadcast(&qemu_pause_cond
);
1011 process_queued_cpu_work(cpu
);
1014 static bool qemu_tcg_should_sleep(CPUState
*cpu
)
1016 if (mttcg_enabled
) {
1017 return cpu_thread_is_idle(cpu
);
1019 return all_cpu_threads_idle();
1023 static void qemu_tcg_wait_io_event(CPUState
*cpu
)
1025 while (qemu_tcg_should_sleep(cpu
)) {
1026 stop_tcg_kick_timer();
1027 qemu_cond_wait(cpu
->halt_cond
, &qemu_global_mutex
);
1030 start_tcg_kick_timer();
1032 qemu_wait_io_event_common(cpu
);
1035 static void qemu_kvm_wait_io_event(CPUState
*cpu
)
1037 while (cpu_thread_is_idle(cpu
)) {
1038 qemu_cond_wait(cpu
->halt_cond
, &qemu_global_mutex
);
1041 qemu_wait_io_event_common(cpu
);
1044 static void *qemu_kvm_cpu_thread_fn(void *arg
)
1046 CPUState
*cpu
= arg
;
1049 rcu_register_thread();
1051 qemu_mutex_lock_iothread();
1052 qemu_thread_get_self(cpu
->thread
);
1053 cpu
->thread_id
= qemu_get_thread_id();
1057 r
= kvm_init_vcpu(cpu
);
1059 fprintf(stderr
, "kvm_init_vcpu failed: %s\n", strerror(-r
));
1063 kvm_init_cpu_signals(cpu
);
1065 /* signal CPU creation */
1066 cpu
->created
= true;
1067 qemu_cond_signal(&qemu_cpu_cond
);
1070 if (cpu_can_run(cpu
)) {
1071 r
= kvm_cpu_exec(cpu
);
1072 if (r
== EXCP_DEBUG
) {
1073 cpu_handle_guest_debug(cpu
);
1076 qemu_kvm_wait_io_event(cpu
);
1077 } while (!cpu
->unplug
|| cpu_can_run(cpu
));
1079 qemu_kvm_destroy_vcpu(cpu
);
1080 cpu
->created
= false;
1081 qemu_cond_signal(&qemu_cpu_cond
);
1082 qemu_mutex_unlock_iothread();
1086 static void *qemu_dummy_cpu_thread_fn(void *arg
)
1089 fprintf(stderr
, "qtest is not supported under Windows\n");
1092 CPUState
*cpu
= arg
;
1096 rcu_register_thread();
1098 qemu_mutex_lock_iothread();
1099 qemu_thread_get_self(cpu
->thread
);
1100 cpu
->thread_id
= qemu_get_thread_id();
1104 sigemptyset(&waitset
);
1105 sigaddset(&waitset
, SIG_IPI
);
1107 /* signal CPU creation */
1108 cpu
->created
= true;
1109 qemu_cond_signal(&qemu_cpu_cond
);
1112 qemu_mutex_unlock_iothread();
1115 r
= sigwait(&waitset
, &sig
);
1116 } while (r
== -1 && (errno
== EAGAIN
|| errno
== EINTR
));
1121 qemu_mutex_lock_iothread();
1122 qemu_wait_io_event_common(cpu
);
1129 static int64_t tcg_get_icount_limit(void)
1133 if (replay_mode
!= REPLAY_MODE_PLAY
) {
1134 deadline
= qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL
);
1136 /* Maintain prior (possibly buggy) behaviour where if no deadline
1137 * was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than
1138 * INT32_MAX nanoseconds ahead, we still use INT32_MAX
1141 if ((deadline
< 0) || (deadline
> INT32_MAX
)) {
1142 deadline
= INT32_MAX
;
1145 return qemu_icount_round(deadline
);
1147 return replay_get_instructions();
1151 static void handle_icount_deadline(void)
1155 qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL
);
1157 if (deadline
== 0) {
1158 qemu_clock_notify(QEMU_CLOCK_VIRTUAL
);
1163 static int tcg_cpu_exec(CPUState
*cpu
)
1166 #ifdef CONFIG_PROFILER
1170 #ifdef CONFIG_PROFILER
1171 ti
= profile_getclock();
1176 timers_state
.qemu_icount
-= (cpu
->icount_decr
.u16
.low
1177 + cpu
->icount_extra
);
1178 cpu
->icount_decr
.u16
.low
= 0;
1179 cpu
->icount_extra
= 0;
1180 count
= tcg_get_icount_limit();
1181 timers_state
.qemu_icount
+= count
;
1182 decr
= (count
> 0xffff) ? 0xffff : count
;
1184 cpu
->icount_decr
.u16
.low
= decr
;
1185 cpu
->icount_extra
= count
;
1187 qemu_mutex_unlock_iothread();
1188 cpu_exec_start(cpu
);
1189 ret
= cpu_exec(cpu
);
1191 qemu_mutex_lock_iothread();
1192 #ifdef CONFIG_PROFILER
1193 tcg_time
+= profile_getclock() - ti
;
1196 /* Fold pending instructions back into the
1197 instruction counter, and clear the interrupt flag. */
1198 timers_state
.qemu_icount
-= (cpu
->icount_decr
.u16
.low
1199 + cpu
->icount_extra
);
1200 cpu
->icount_decr
.u32
= 0;
1201 cpu
->icount_extra
= 0;
1202 replay_account_executed_instructions();
1207 /* Destroy any remaining vCPUs which have been unplugged and have
1210 static void deal_with_unplugged_cpus(void)
1215 if (cpu
->unplug
&& !cpu_can_run(cpu
)) {
1216 qemu_tcg_destroy_vcpu(cpu
);
1217 cpu
->created
= false;
1218 qemu_cond_signal(&qemu_cpu_cond
);
1224 /* Single-threaded TCG
1226 * In the single-threaded case each vCPU is simulated in turn. If
1227 * there is more than a single vCPU we create a simple timer to kick
1228 * the vCPU and ensure we don't get stuck in a tight loop in one vCPU.
1229 * This is done explicitly rather than relying on side-effects
1233 static void *qemu_tcg_rr_cpu_thread_fn(void *arg
)
1235 CPUState
*cpu
= arg
;
1237 rcu_register_thread();
1239 qemu_mutex_lock_iothread();
1240 qemu_thread_get_self(cpu
->thread
);
1243 cpu
->thread_id
= qemu_get_thread_id();
1244 cpu
->created
= true;
1247 qemu_cond_signal(&qemu_cpu_cond
);
1249 /* wait for initial kick-off after machine start */
1250 while (first_cpu
->stopped
) {
1251 qemu_cond_wait(first_cpu
->halt_cond
, &qemu_global_mutex
);
1253 /* process any pending work */
1256 qemu_wait_io_event_common(cpu
);
1260 start_tcg_kick_timer();
1264 /* process any pending work */
1265 cpu
->exit_request
= 1;
1268 /* Account partial waits to QEMU_CLOCK_VIRTUAL. */
1269 qemu_account_warp_timer();
1275 while (cpu
&& !cpu
->queued_work_first
&& !cpu
->exit_request
) {
1277 atomic_mb_set(&tcg_current_rr_cpu
, cpu
);
1280 qemu_clock_enable(QEMU_CLOCK_VIRTUAL
,
1281 (cpu
->singlestep_enabled
& SSTEP_NOTIMER
) == 0);
1283 if (cpu_can_run(cpu
)) {
1285 r
= tcg_cpu_exec(cpu
);
1286 if (r
== EXCP_DEBUG
) {
1287 cpu_handle_guest_debug(cpu
);
1289 } else if (r
== EXCP_ATOMIC
) {
1290 qemu_mutex_unlock_iothread();
1291 cpu_exec_step_atomic(cpu
);
1292 qemu_mutex_lock_iothread();
1295 } else if (cpu
->stop
) {
1297 cpu
= CPU_NEXT(cpu
);
1302 cpu
= CPU_NEXT(cpu
);
1303 } /* while (cpu && !cpu->exit_request).. */
1305 /* Does not need atomic_mb_set because a spurious wakeup is okay. */
1306 atomic_set(&tcg_current_rr_cpu
, NULL
);
1308 if (cpu
&& cpu
->exit_request
) {
1309 atomic_mb_set(&cpu
->exit_request
, 0);
1312 handle_icount_deadline();
1314 qemu_tcg_wait_io_event(cpu
? cpu
: QTAILQ_FIRST(&cpus
));
1315 deal_with_unplugged_cpus();
1321 static void *qemu_hax_cpu_thread_fn(void *arg
)
1323 CPUState
*cpu
= arg
;
1325 qemu_thread_get_self(cpu
->thread
);
1326 qemu_mutex_lock(&qemu_global_mutex
);
1328 cpu
->thread_id
= qemu_get_thread_id();
1329 cpu
->created
= true;
1334 qemu_cond_signal(&qemu_cpu_cond
);
1337 if (cpu_can_run(cpu
)) {
1338 r
= hax_smp_cpu_exec(cpu
);
1339 if (r
== EXCP_DEBUG
) {
1340 cpu_handle_guest_debug(cpu
);
1344 while (cpu_thread_is_idle(cpu
)) {
1345 qemu_cond_wait(cpu
->halt_cond
, &qemu_global_mutex
);
1350 qemu_wait_io_event_common(cpu
);
1356 static void CALLBACK
dummy_apc_func(ULONG_PTR unused
)
1361 /* Multi-threaded TCG
1363 * In the multi-threaded case each vCPU has its own thread. The TLS
1364 * variable current_cpu can be used deep in the code to find the
1365 * current CPUState for a given thread.
1368 static void *qemu_tcg_cpu_thread_fn(void *arg
)
1370 CPUState
*cpu
= arg
;
1372 rcu_register_thread();
1374 qemu_mutex_lock_iothread();
1375 qemu_thread_get_self(cpu
->thread
);
1377 cpu
->thread_id
= qemu_get_thread_id();
1378 cpu
->created
= true;
1381 qemu_cond_signal(&qemu_cpu_cond
);
1383 /* process any pending work */
1384 cpu
->exit_request
= 1;
1387 if (cpu_can_run(cpu
)) {
1389 r
= tcg_cpu_exec(cpu
);
1392 cpu_handle_guest_debug(cpu
);
1395 /* during start-up the vCPU is reset and the thread is
1396 * kicked several times. If we don't ensure we go back
1397 * to sleep in the halted state we won't cleanly
1398 * start-up when the vCPU is enabled.
1400 * cpu->halted should ensure we sleep in wait_io_event
1402 g_assert(cpu
->halted
);
1405 qemu_mutex_unlock_iothread();
1406 cpu_exec_step_atomic(cpu
);
1407 qemu_mutex_lock_iothread();
1409 /* Ignore everything else? */
1414 handle_icount_deadline();
1416 atomic_mb_set(&cpu
->exit_request
, 0);
1417 qemu_tcg_wait_io_event(cpu
);
1423 static void qemu_cpu_kick_thread(CPUState
*cpu
)
1428 if (cpu
->thread_kicked
) {
1431 cpu
->thread_kicked
= true;
1432 err
= pthread_kill(cpu
->thread
->thread
, SIG_IPI
);
1434 fprintf(stderr
, "qemu:%s: %s", __func__
, strerror(err
));
1438 if (!qemu_cpu_is_self(cpu
)) {
1439 if (!QueueUserAPC(dummy_apc_func
, cpu
->hThread
, 0)) {
1440 fprintf(stderr
, "%s: QueueUserAPC failed with error %lu\n",
1441 __func__
, GetLastError());
1448 void qemu_cpu_kick(CPUState
*cpu
)
1450 qemu_cond_broadcast(cpu
->halt_cond
);
1451 if (tcg_enabled()) {
1453 /* NOP unless doing single-thread RR */
1454 qemu_cpu_kick_rr_cpu();
1456 if (hax_enabled()) {
1458 * FIXME: race condition with the exit_request check in
1461 cpu
->exit_request
= 1;
1463 qemu_cpu_kick_thread(cpu
);
1467 void qemu_cpu_kick_self(void)
1469 assert(current_cpu
);
1470 qemu_cpu_kick_thread(current_cpu
);
1473 bool qemu_cpu_is_self(CPUState
*cpu
)
1475 return qemu_thread_is_self(cpu
->thread
);
1478 bool qemu_in_vcpu_thread(void)
1480 return current_cpu
&& qemu_cpu_is_self(current_cpu
);
1483 static __thread
bool iothread_locked
= false;
1485 bool qemu_mutex_iothread_locked(void)
1487 return iothread_locked
;
1490 void qemu_mutex_lock_iothread(void)
1492 g_assert(!qemu_mutex_iothread_locked());
1493 qemu_mutex_lock(&qemu_global_mutex
);
1494 iothread_locked
= true;
1497 void qemu_mutex_unlock_iothread(void)
1499 g_assert(qemu_mutex_iothread_locked());
1500 iothread_locked
= false;
1501 qemu_mutex_unlock(&qemu_global_mutex
);
1504 static bool all_vcpus_paused(void)
1509 if (!cpu
->stopped
) {
1517 void pause_all_vcpus(void)
1521 qemu_clock_enable(QEMU_CLOCK_VIRTUAL
, false);
1527 if (qemu_in_vcpu_thread()) {
1531 while (!all_vcpus_paused()) {
1532 qemu_cond_wait(&qemu_pause_cond
, &qemu_global_mutex
);
1539 void cpu_resume(CPUState
*cpu
)
1542 cpu
->stopped
= false;
1546 void resume_all_vcpus(void)
1550 qemu_clock_enable(QEMU_CLOCK_VIRTUAL
, true);
1556 void cpu_remove(CPUState
*cpu
)
1563 void cpu_remove_sync(CPUState
*cpu
)
1566 while (cpu
->created
) {
1567 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1571 /* For temporary buffers for forming a name */
1572 #define VCPU_THREAD_NAME_SIZE 16
1574 static void qemu_tcg_init_vcpu(CPUState
*cpu
)
1576 char thread_name
[VCPU_THREAD_NAME_SIZE
];
1577 static QemuCond
*single_tcg_halt_cond
;
1578 static QemuThread
*single_tcg_cpu_thread
;
1580 if (qemu_tcg_mttcg_enabled() || !single_tcg_cpu_thread
) {
1581 cpu
->thread
= g_malloc0(sizeof(QemuThread
));
1582 cpu
->halt_cond
= g_malloc0(sizeof(QemuCond
));
1583 qemu_cond_init(cpu
->halt_cond
);
1585 if (qemu_tcg_mttcg_enabled()) {
1586 /* create a thread per vCPU with TCG (MTTCG) */
1587 parallel_cpus
= true;
1588 snprintf(thread_name
, VCPU_THREAD_NAME_SIZE
, "CPU %d/TCG",
1591 qemu_thread_create(cpu
->thread
, thread_name
, qemu_tcg_cpu_thread_fn
,
1592 cpu
, QEMU_THREAD_JOINABLE
);
1595 /* share a single thread for all cpus with TCG */
1596 snprintf(thread_name
, VCPU_THREAD_NAME_SIZE
, "ALL CPUs/TCG");
1597 qemu_thread_create(cpu
->thread
, thread_name
,
1598 qemu_tcg_rr_cpu_thread_fn
,
1599 cpu
, QEMU_THREAD_JOINABLE
);
1601 single_tcg_halt_cond
= cpu
->halt_cond
;
1602 single_tcg_cpu_thread
= cpu
->thread
;
1605 cpu
->hThread
= qemu_thread_get_handle(cpu
->thread
);
1607 while (!cpu
->created
) {
1608 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1611 /* For non-MTTCG cases we share the thread */
1612 cpu
->thread
= single_tcg_cpu_thread
;
1613 cpu
->halt_cond
= single_tcg_halt_cond
;
1617 static void qemu_hax_start_vcpu(CPUState
*cpu
)
1619 char thread_name
[VCPU_THREAD_NAME_SIZE
];
1621 cpu
->thread
= g_malloc0(sizeof(QemuThread
));
1622 cpu
->halt_cond
= g_malloc0(sizeof(QemuCond
));
1623 qemu_cond_init(cpu
->halt_cond
);
1625 snprintf(thread_name
, VCPU_THREAD_NAME_SIZE
, "CPU %d/HAX",
1627 qemu_thread_create(cpu
->thread
, thread_name
, qemu_hax_cpu_thread_fn
,
1628 cpu
, QEMU_THREAD_JOINABLE
);
1630 cpu
->hThread
= qemu_thread_get_handle(cpu
->thread
);
1632 while (!cpu
->created
) {
1633 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1637 static void qemu_kvm_start_vcpu(CPUState
*cpu
)
1639 char thread_name
[VCPU_THREAD_NAME_SIZE
];
1641 cpu
->thread
= g_malloc0(sizeof(QemuThread
));
1642 cpu
->halt_cond
= g_malloc0(sizeof(QemuCond
));
1643 qemu_cond_init(cpu
->halt_cond
);
1644 snprintf(thread_name
, VCPU_THREAD_NAME_SIZE
, "CPU %d/KVM",
1646 qemu_thread_create(cpu
->thread
, thread_name
, qemu_kvm_cpu_thread_fn
,
1647 cpu
, QEMU_THREAD_JOINABLE
);
1648 while (!cpu
->created
) {
1649 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1653 static void qemu_dummy_start_vcpu(CPUState
*cpu
)
1655 char thread_name
[VCPU_THREAD_NAME_SIZE
];
1657 cpu
->thread
= g_malloc0(sizeof(QemuThread
));
1658 cpu
->halt_cond
= g_malloc0(sizeof(QemuCond
));
1659 qemu_cond_init(cpu
->halt_cond
);
1660 snprintf(thread_name
, VCPU_THREAD_NAME_SIZE
, "CPU %d/DUMMY",
1662 qemu_thread_create(cpu
->thread
, thread_name
, qemu_dummy_cpu_thread_fn
, cpu
,
1663 QEMU_THREAD_JOINABLE
);
1664 while (!cpu
->created
) {
1665 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1669 void qemu_init_vcpu(CPUState
*cpu
)
1671 cpu
->nr_cores
= smp_cores
;
1672 cpu
->nr_threads
= smp_threads
;
1673 cpu
->stopped
= true;
1676 /* If the target cpu hasn't set up any address spaces itself,
1677 * give it the default one.
1679 AddressSpace
*as
= address_space_init_shareable(cpu
->memory
,
1682 cpu_address_space_init(cpu
, as
, 0);
1685 if (kvm_enabled()) {
1686 qemu_kvm_start_vcpu(cpu
);
1687 } else if (hax_enabled()) {
1688 qemu_hax_start_vcpu(cpu
);
1689 } else if (tcg_enabled()) {
1690 qemu_tcg_init_vcpu(cpu
);
1692 qemu_dummy_start_vcpu(cpu
);
1696 void cpu_stop_current(void)
1699 current_cpu
->stop
= false;
1700 current_cpu
->stopped
= true;
1701 cpu_exit(current_cpu
);
1702 qemu_cond_broadcast(&qemu_pause_cond
);
1706 int vm_stop(RunState state
)
1708 if (qemu_in_vcpu_thread()) {
1709 qemu_system_vmstop_request_prepare();
1710 qemu_system_vmstop_request(state
);
1712 * FIXME: should not return to device code in case
1713 * vm_stop() has been requested.
1719 return do_vm_stop(state
);
1723 * Prepare for (re)starting the VM.
1724 * Returns -1 if the vCPUs are not to be restarted (e.g. if they are already
1725 * running or in case of an error condition), 0 otherwise.
1727 int vm_prepare_start(void)
1732 qemu_vmstop_requested(&requested
);
1733 if (runstate_is_running() && requested
== RUN_STATE__MAX
) {
1737 /* Ensure that a STOP/RESUME pair of events is emitted if a
1738 * vmstop request was pending. The BLOCK_IO_ERROR event, for
1739 * example, according to documentation is always followed by
1742 if (runstate_is_running()) {
1743 qapi_event_send_stop(&error_abort
);
1746 replay_enable_events();
1748 runstate_set(RUN_STATE_RUNNING
);
1749 vm_state_notify(1, RUN_STATE_RUNNING
);
1752 /* We are sending this now, but the CPUs will be resumed shortly later */
1753 qapi_event_send_resume(&error_abort
);
1759 if (!vm_prepare_start()) {
1764 /* does a state transition even if the VM is already stopped,
1765 current state is forgotten forever */
1766 int vm_stop_force_state(RunState state
)
1768 if (runstate_is_running()) {
1769 return vm_stop(state
);
1771 runstate_set(state
);
1774 /* Make sure to return an error if the flush in a previous vm_stop()
1776 return bdrv_flush_all();
1780 void list_cpus(FILE *f
, fprintf_function cpu_fprintf
, const char *optarg
)
1782 /* XXX: implement xxx_cpu_list for targets that still miss it */
1783 #if defined(cpu_list)
1784 cpu_list(f
, cpu_fprintf
);
1788 CpuInfoList
*qmp_query_cpus(Error
**errp
)
1790 CpuInfoList
*head
= NULL
, *cur_item
= NULL
;
1795 #if defined(TARGET_I386)
1796 X86CPU
*x86_cpu
= X86_CPU(cpu
);
1797 CPUX86State
*env
= &x86_cpu
->env
;
1798 #elif defined(TARGET_PPC)
1799 PowerPCCPU
*ppc_cpu
= POWERPC_CPU(cpu
);
1800 CPUPPCState
*env
= &ppc_cpu
->env
;
1801 #elif defined(TARGET_SPARC)
1802 SPARCCPU
*sparc_cpu
= SPARC_CPU(cpu
);
1803 CPUSPARCState
*env
= &sparc_cpu
->env
;
1804 #elif defined(TARGET_MIPS)
1805 MIPSCPU
*mips_cpu
= MIPS_CPU(cpu
);
1806 CPUMIPSState
*env
= &mips_cpu
->env
;
1807 #elif defined(TARGET_TRICORE)
1808 TriCoreCPU
*tricore_cpu
= TRICORE_CPU(cpu
);
1809 CPUTriCoreState
*env
= &tricore_cpu
->env
;
1812 cpu_synchronize_state(cpu
);
1814 info
= g_malloc0(sizeof(*info
));
1815 info
->value
= g_malloc0(sizeof(*info
->value
));
1816 info
->value
->CPU
= cpu
->cpu_index
;
1817 info
->value
->current
= (cpu
== first_cpu
);
1818 info
->value
->halted
= cpu
->halted
;
1819 info
->value
->qom_path
= object_get_canonical_path(OBJECT(cpu
));
1820 info
->value
->thread_id
= cpu
->thread_id
;
1821 #if defined(TARGET_I386)
1822 info
->value
->arch
= CPU_INFO_ARCH_X86
;
1823 info
->value
->u
.x86
.pc
= env
->eip
+ env
->segs
[R_CS
].base
;
1824 #elif defined(TARGET_PPC)
1825 info
->value
->arch
= CPU_INFO_ARCH_PPC
;
1826 info
->value
->u
.ppc
.nip
= env
->nip
;
1827 #elif defined(TARGET_SPARC)
1828 info
->value
->arch
= CPU_INFO_ARCH_SPARC
;
1829 info
->value
->u
.q_sparc
.pc
= env
->pc
;
1830 info
->value
->u
.q_sparc
.npc
= env
->npc
;
1831 #elif defined(TARGET_MIPS)
1832 info
->value
->arch
= CPU_INFO_ARCH_MIPS
;
1833 info
->value
->u
.q_mips
.PC
= env
->active_tc
.PC
;
1834 #elif defined(TARGET_TRICORE)
1835 info
->value
->arch
= CPU_INFO_ARCH_TRICORE
;
1836 info
->value
->u
.tricore
.PC
= env
->PC
;
1838 info
->value
->arch
= CPU_INFO_ARCH_OTHER
;
1841 /* XXX: waiting for the qapi to support GSList */
1843 head
= cur_item
= info
;
1845 cur_item
->next
= info
;
1853 void qmp_memsave(int64_t addr
, int64_t size
, const char *filename
,
1854 bool has_cpu
, int64_t cpu_index
, Error
**errp
)
1860 int64_t orig_addr
= addr
, orig_size
= size
;
1866 cpu
= qemu_get_cpu(cpu_index
);
1868 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "cpu-index",
1873 f
= fopen(filename
, "wb");
1875 error_setg_file_open(errp
, errno
, filename
);
1883 if (cpu_memory_rw_debug(cpu
, addr
, buf
, l
, 0) != 0) {
1884 error_setg(errp
, "Invalid addr 0x%016" PRIx64
"/size %" PRId64
1885 " specified", orig_addr
, orig_size
);
1888 if (fwrite(buf
, 1, l
, f
) != l
) {
1889 error_setg(errp
, QERR_IO_ERROR
);
1900 void qmp_pmemsave(int64_t addr
, int64_t size
, const char *filename
,
1907 f
= fopen(filename
, "wb");
1909 error_setg_file_open(errp
, errno
, filename
);
1917 cpu_physical_memory_read(addr
, buf
, l
);
1918 if (fwrite(buf
, 1, l
, f
) != l
) {
1919 error_setg(errp
, QERR_IO_ERROR
);
1930 void qmp_inject_nmi(Error
**errp
)
1932 nmi_monitor_handle(monitor_get_cpu_index(), errp
);
1935 void dump_drift_info(FILE *f
, fprintf_function cpu_fprintf
)
1941 cpu_fprintf(f
, "Host - Guest clock %"PRIi64
" ms\n",
1942 (cpu_get_clock() - cpu_get_icount())/SCALE_MS
);
1943 if (icount_align_option
) {
1944 cpu_fprintf(f
, "Max guest delay %"PRIi64
" ms\n", -max_delay
/SCALE_MS
);
1945 cpu_fprintf(f
, "Max guest advance %"PRIi64
" ms\n", max_advance
/SCALE_MS
);
1947 cpu_fprintf(f
, "Max guest delay NA\n");
1948 cpu_fprintf(f
, "Max guest advance NA\n");