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"
55 #include "qemu/compatfd.h"
60 #include <sys/prctl.h>
63 #define PR_MCE_KILL 33
66 #ifndef PR_MCE_KILL_SET
67 #define PR_MCE_KILL_SET 1
70 #ifndef PR_MCE_KILL_EARLY
71 #define PR_MCE_KILL_EARLY 1
74 #endif /* CONFIG_LINUX */
79 /* vcpu throttling controls */
80 static QEMUTimer
*throttle_timer
;
81 static unsigned int throttle_percentage
;
83 #define CPU_THROTTLE_PCT_MIN 1
84 #define CPU_THROTTLE_PCT_MAX 99
85 #define CPU_THROTTLE_TIMESLICE_NS 10000000
87 bool cpu_is_stopped(CPUState
*cpu
)
89 return cpu
->stopped
|| !runstate_is_running();
92 static bool cpu_thread_is_idle(CPUState
*cpu
)
94 if (cpu
->stop
|| cpu
->queued_work_first
) {
97 if (cpu_is_stopped(cpu
)) {
100 if (!cpu
->halted
|| cpu_has_work(cpu
) ||
101 kvm_halt_in_kernel()) {
107 static bool all_cpu_threads_idle(void)
112 if (!cpu_thread_is_idle(cpu
)) {
119 /***********************************************************/
120 /* guest cycle counter */
122 /* Protected by TimersState seqlock */
124 static bool icount_sleep
= true;
125 static int64_t vm_clock_warp_start
= -1;
126 /* Conversion factor from emulated instructions to virtual clock ticks. */
127 static int icount_time_shift
;
128 /* Arbitrarily pick 1MIPS as the minimum allowable speed. */
129 #define MAX_ICOUNT_SHIFT 10
131 static QEMUTimer
*icount_rt_timer
;
132 static QEMUTimer
*icount_vm_timer
;
133 static QEMUTimer
*icount_warp_timer
;
135 typedef struct TimersState
{
136 /* Protected by BQL. */
137 int64_t cpu_ticks_prev
;
138 int64_t cpu_ticks_offset
;
140 /* cpu_clock_offset can be read out of BQL, so protect it with
143 QemuSeqLock vm_clock_seqlock
;
144 int64_t cpu_clock_offset
;
145 int32_t cpu_ticks_enabled
;
148 /* Compensate for varying guest execution speed. */
149 int64_t qemu_icount_bias
;
150 /* Only written by TCG thread */
154 static TimersState timers_state
;
158 * We default to false if we know other options have been enabled
159 * which are currently incompatible with MTTCG. Otherwise when each
160 * guest (target) has been updated to support:
161 * - atomic instructions
162 * - memory ordering primitives (barriers)
163 * they can set the appropriate CONFIG flags in ${target}-softmmu.mak
165 * Once a guest architecture has been converted to the new primitives
166 * there are two remaining limitations to check.
168 * - The guest can't be oversized (e.g. 64 bit guest on 32 bit host)
169 * - The host must have a stronger memory order than the guest
171 * It may be possible in future to support strong guests on weak hosts
172 * but that will require tagging all load/stores in a guest with their
173 * implicit memory order requirements which would likely slow things
177 static bool check_tcg_memory_orders_compatible(void)
179 #if defined(TCG_GUEST_DEFAULT_MO) && defined(TCG_TARGET_DEFAULT_MO)
180 return (TCG_GUEST_DEFAULT_MO
& ~TCG_TARGET_DEFAULT_MO
) == 0;
186 static bool default_mttcg_enabled(void)
188 QemuOpts
*icount_opts
= qemu_find_opts_singleton("icount");
189 const char *rr
= qemu_opt_get(icount_opts
, "rr");
191 if (rr
|| TCG_OVERSIZED_GUEST
) {
194 #ifdef TARGET_SUPPORTS_MTTCG
195 return check_tcg_memory_orders_compatible();
202 void qemu_tcg_configure(QemuOpts
*opts
, Error
**errp
)
204 const char *t
= qemu_opt_get(opts
, "thread");
206 if (strcmp(t
, "multi") == 0) {
207 if (TCG_OVERSIZED_GUEST
) {
208 error_setg(errp
, "No MTTCG when guest word size > hosts");
210 if (!check_tcg_memory_orders_compatible()) {
211 error_report("Guest expects a stronger memory ordering "
212 "than the host provides");
213 error_printf("This may cause strange/hard to debug errors");
215 mttcg_enabled
= true;
217 } else if (strcmp(t
, "single") == 0) {
218 mttcg_enabled
= false;
220 error_setg(errp
, "Invalid 'thread' setting %s", t
);
223 mttcg_enabled
= default_mttcg_enabled();
227 int64_t cpu_get_icount_raw(void)
230 CPUState
*cpu
= current_cpu
;
232 icount
= timers_state
.qemu_icount
;
234 if (!cpu
->can_do_io
) {
235 fprintf(stderr
, "Bad icount read\n");
238 icount
-= (cpu
->icount_decr
.u16
.low
+ cpu
->icount_extra
);
243 /* Return the virtual CPU time, based on the instruction counter. */
244 static int64_t cpu_get_icount_locked(void)
246 int64_t icount
= cpu_get_icount_raw();
247 return timers_state
.qemu_icount_bias
+ cpu_icount_to_ns(icount
);
250 int64_t cpu_get_icount(void)
256 start
= seqlock_read_begin(&timers_state
.vm_clock_seqlock
);
257 icount
= cpu_get_icount_locked();
258 } while (seqlock_read_retry(&timers_state
.vm_clock_seqlock
, start
));
263 int64_t cpu_icount_to_ns(int64_t icount
)
265 return icount
<< icount_time_shift
;
268 /* return the time elapsed in VM between vm_start and vm_stop. Unless
269 * icount is active, cpu_get_ticks() uses units of the host CPU cycle
272 * Caller must hold the BQL
274 int64_t cpu_get_ticks(void)
279 return cpu_get_icount();
282 ticks
= timers_state
.cpu_ticks_offset
;
283 if (timers_state
.cpu_ticks_enabled
) {
284 ticks
+= cpu_get_host_ticks();
287 if (timers_state
.cpu_ticks_prev
> ticks
) {
288 /* Note: non increasing ticks may happen if the host uses
290 timers_state
.cpu_ticks_offset
+= timers_state
.cpu_ticks_prev
- ticks
;
291 ticks
= timers_state
.cpu_ticks_prev
;
294 timers_state
.cpu_ticks_prev
= ticks
;
298 static int64_t cpu_get_clock_locked(void)
302 time
= timers_state
.cpu_clock_offset
;
303 if (timers_state
.cpu_ticks_enabled
) {
310 /* Return the monotonic time elapsed in VM, i.e.,
311 * the time between vm_start and vm_stop
313 int64_t cpu_get_clock(void)
319 start
= seqlock_read_begin(&timers_state
.vm_clock_seqlock
);
320 ti
= cpu_get_clock_locked();
321 } while (seqlock_read_retry(&timers_state
.vm_clock_seqlock
, start
));
326 /* enable cpu_get_ticks()
327 * Caller must hold BQL which serves as mutex for vm_clock_seqlock.
329 void cpu_enable_ticks(void)
331 /* Here, the really thing protected by seqlock is cpu_clock_offset. */
332 seqlock_write_begin(&timers_state
.vm_clock_seqlock
);
333 if (!timers_state
.cpu_ticks_enabled
) {
334 timers_state
.cpu_ticks_offset
-= cpu_get_host_ticks();
335 timers_state
.cpu_clock_offset
-= get_clock();
336 timers_state
.cpu_ticks_enabled
= 1;
338 seqlock_write_end(&timers_state
.vm_clock_seqlock
);
341 /* disable cpu_get_ticks() : the clock is stopped. You must not call
342 * cpu_get_ticks() after that.
343 * Caller must hold BQL which serves as mutex for vm_clock_seqlock.
345 void cpu_disable_ticks(void)
347 /* Here, the really thing protected by seqlock is cpu_clock_offset. */
348 seqlock_write_begin(&timers_state
.vm_clock_seqlock
);
349 if (timers_state
.cpu_ticks_enabled
) {
350 timers_state
.cpu_ticks_offset
+= cpu_get_host_ticks();
351 timers_state
.cpu_clock_offset
= cpu_get_clock_locked();
352 timers_state
.cpu_ticks_enabled
= 0;
354 seqlock_write_end(&timers_state
.vm_clock_seqlock
);
357 /* Correlation between real and virtual time is always going to be
358 fairly approximate, so ignore small variation.
359 When the guest is idle real and virtual time will be aligned in
361 #define ICOUNT_WOBBLE (NANOSECONDS_PER_SECOND / 10)
363 static void icount_adjust(void)
369 /* Protected by TimersState mutex. */
370 static int64_t last_delta
;
372 /* If the VM is not running, then do nothing. */
373 if (!runstate_is_running()) {
377 seqlock_write_begin(&timers_state
.vm_clock_seqlock
);
378 cur_time
= cpu_get_clock_locked();
379 cur_icount
= cpu_get_icount_locked();
381 delta
= cur_icount
- cur_time
;
382 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
384 && last_delta
+ ICOUNT_WOBBLE
< delta
* 2
385 && icount_time_shift
> 0) {
386 /* The guest is getting too far ahead. Slow time down. */
390 && last_delta
- ICOUNT_WOBBLE
> delta
* 2
391 && icount_time_shift
< MAX_ICOUNT_SHIFT
) {
392 /* The guest is getting too far behind. Speed time up. */
396 timers_state
.qemu_icount_bias
= cur_icount
397 - (timers_state
.qemu_icount
<< icount_time_shift
);
398 seqlock_write_end(&timers_state
.vm_clock_seqlock
);
401 static void icount_adjust_rt(void *opaque
)
403 timer_mod(icount_rt_timer
,
404 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT
) + 1000);
408 static void icount_adjust_vm(void *opaque
)
410 timer_mod(icount_vm_timer
,
411 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) +
412 NANOSECONDS_PER_SECOND
/ 10);
416 static int64_t qemu_icount_round(int64_t count
)
418 return (count
+ (1 << icount_time_shift
) - 1) >> icount_time_shift
;
421 static void icount_warp_rt(void)
426 /* The icount_warp_timer is rescheduled soon after vm_clock_warp_start
427 * changes from -1 to another value, so the race here is okay.
430 seq
= seqlock_read_begin(&timers_state
.vm_clock_seqlock
);
431 warp_start
= vm_clock_warp_start
;
432 } while (seqlock_read_retry(&timers_state
.vm_clock_seqlock
, seq
));
434 if (warp_start
== -1) {
438 seqlock_write_begin(&timers_state
.vm_clock_seqlock
);
439 if (runstate_is_running()) {
440 int64_t clock
= REPLAY_CLOCK(REPLAY_CLOCK_VIRTUAL_RT
,
441 cpu_get_clock_locked());
444 warp_delta
= clock
- vm_clock_warp_start
;
445 if (use_icount
== 2) {
447 * In adaptive mode, do not let QEMU_CLOCK_VIRTUAL run too
448 * far ahead of real time.
450 int64_t cur_icount
= cpu_get_icount_locked();
451 int64_t delta
= clock
- cur_icount
;
452 warp_delta
= MIN(warp_delta
, delta
);
454 timers_state
.qemu_icount_bias
+= warp_delta
;
456 vm_clock_warp_start
= -1;
457 seqlock_write_end(&timers_state
.vm_clock_seqlock
);
459 if (qemu_clock_expired(QEMU_CLOCK_VIRTUAL
)) {
460 qemu_clock_notify(QEMU_CLOCK_VIRTUAL
);
464 static void icount_timer_cb(void *opaque
)
466 /* No need for a checkpoint because the timer already synchronizes
467 * with CHECKPOINT_CLOCK_VIRTUAL_RT.
472 void qtest_clock_warp(int64_t dest
)
474 int64_t clock
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
475 AioContext
*aio_context
;
476 assert(qtest_enabled());
477 aio_context
= qemu_get_aio_context();
478 while (clock
< dest
) {
479 int64_t deadline
= qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL
);
480 int64_t warp
= qemu_soonest_timeout(dest
- clock
, deadline
);
482 seqlock_write_begin(&timers_state
.vm_clock_seqlock
);
483 timers_state
.qemu_icount_bias
+= warp
;
484 seqlock_write_end(&timers_state
.vm_clock_seqlock
);
486 qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL
);
487 timerlist_run_timers(aio_context
->tlg
.tl
[QEMU_CLOCK_VIRTUAL
]);
488 clock
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
490 qemu_clock_notify(QEMU_CLOCK_VIRTUAL
);
493 void qemu_start_warp_timer(void)
502 /* Nothing to do if the VM is stopped: QEMU_CLOCK_VIRTUAL timers
503 * do not fire, so computing the deadline does not make sense.
505 if (!runstate_is_running()) {
509 /* warp clock deterministically in record/replay mode */
510 if (!replay_checkpoint(CHECKPOINT_CLOCK_WARP_START
)) {
514 if (!all_cpu_threads_idle()) {
518 if (qtest_enabled()) {
519 /* When testing, qtest commands advance icount. */
523 /* We want to use the earliest deadline from ALL vm_clocks */
524 clock
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT
);
525 deadline
= qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL
);
527 static bool notified
;
528 if (!icount_sleep
&& !notified
) {
529 error_report("WARNING: icount sleep disabled and no active timers");
537 * Ensure QEMU_CLOCK_VIRTUAL proceeds even when the virtual CPU goes to
538 * sleep. Otherwise, the CPU might be waiting for a future timer
539 * interrupt to wake it up, but the interrupt never comes because
540 * the vCPU isn't running any insns and thus doesn't advance the
541 * QEMU_CLOCK_VIRTUAL.
545 * We never let VCPUs sleep in no sleep icount mode.
546 * If there is a pending QEMU_CLOCK_VIRTUAL timer we just advance
547 * to the next QEMU_CLOCK_VIRTUAL event and notify it.
548 * It is useful when we want a deterministic execution time,
549 * isolated from host latencies.
551 seqlock_write_begin(&timers_state
.vm_clock_seqlock
);
552 timers_state
.qemu_icount_bias
+= deadline
;
553 seqlock_write_end(&timers_state
.vm_clock_seqlock
);
554 qemu_clock_notify(QEMU_CLOCK_VIRTUAL
);
557 * We do stop VCPUs and only advance QEMU_CLOCK_VIRTUAL after some
558 * "real" time, (related to the time left until the next event) has
559 * passed. The QEMU_CLOCK_VIRTUAL_RT clock will do this.
560 * This avoids that the warps are visible externally; for example,
561 * you will not be sending network packets continuously instead of
564 seqlock_write_begin(&timers_state
.vm_clock_seqlock
);
565 if (vm_clock_warp_start
== -1 || vm_clock_warp_start
> clock
) {
566 vm_clock_warp_start
= clock
;
568 seqlock_write_end(&timers_state
.vm_clock_seqlock
);
569 timer_mod_anticipate(icount_warp_timer
, clock
+ deadline
);
571 } else if (deadline
== 0) {
572 qemu_clock_notify(QEMU_CLOCK_VIRTUAL
);
576 static void qemu_account_warp_timer(void)
578 if (!use_icount
|| !icount_sleep
) {
582 /* Nothing to do if the VM is stopped: QEMU_CLOCK_VIRTUAL timers
583 * do not fire, so computing the deadline does not make sense.
585 if (!runstate_is_running()) {
589 /* warp clock deterministically in record/replay mode */
590 if (!replay_checkpoint(CHECKPOINT_CLOCK_WARP_ACCOUNT
)) {
594 timer_del(icount_warp_timer
);
598 static bool icount_state_needed(void *opaque
)
604 * This is a subsection for icount migration.
606 static const VMStateDescription icount_vmstate_timers
= {
607 .name
= "timer/icount",
609 .minimum_version_id
= 1,
610 .needed
= icount_state_needed
,
611 .fields
= (VMStateField
[]) {
612 VMSTATE_INT64(qemu_icount_bias
, TimersState
),
613 VMSTATE_INT64(qemu_icount
, TimersState
),
614 VMSTATE_END_OF_LIST()
618 static const VMStateDescription vmstate_timers
= {
621 .minimum_version_id
= 1,
622 .fields
= (VMStateField
[]) {
623 VMSTATE_INT64(cpu_ticks_offset
, TimersState
),
624 VMSTATE_INT64(dummy
, TimersState
),
625 VMSTATE_INT64_V(cpu_clock_offset
, TimersState
, 2),
626 VMSTATE_END_OF_LIST()
628 .subsections
= (const VMStateDescription
*[]) {
629 &icount_vmstate_timers
,
634 static void cpu_throttle_thread(CPUState
*cpu
, run_on_cpu_data opaque
)
637 double throttle_ratio
;
640 if (!cpu_throttle_get_percentage()) {
644 pct
= (double)cpu_throttle_get_percentage()/100;
645 throttle_ratio
= pct
/ (1 - pct
);
646 sleeptime_ns
= (long)(throttle_ratio
* CPU_THROTTLE_TIMESLICE_NS
);
648 qemu_mutex_unlock_iothread();
649 atomic_set(&cpu
->throttle_thread_scheduled
, 0);
650 g_usleep(sleeptime_ns
/ 1000); /* Convert ns to us for usleep call */
651 qemu_mutex_lock_iothread();
654 static void cpu_throttle_timer_tick(void *opaque
)
659 /* Stop the timer if needed */
660 if (!cpu_throttle_get_percentage()) {
664 if (!atomic_xchg(&cpu
->throttle_thread_scheduled
, 1)) {
665 async_run_on_cpu(cpu
, cpu_throttle_thread
,
670 pct
= (double)cpu_throttle_get_percentage()/100;
671 timer_mod(throttle_timer
, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT
) +
672 CPU_THROTTLE_TIMESLICE_NS
/ (1-pct
));
675 void cpu_throttle_set(int new_throttle_pct
)
677 /* Ensure throttle percentage is within valid range */
678 new_throttle_pct
= MIN(new_throttle_pct
, CPU_THROTTLE_PCT_MAX
);
679 new_throttle_pct
= MAX(new_throttle_pct
, CPU_THROTTLE_PCT_MIN
);
681 atomic_set(&throttle_percentage
, new_throttle_pct
);
683 timer_mod(throttle_timer
, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT
) +
684 CPU_THROTTLE_TIMESLICE_NS
);
687 void cpu_throttle_stop(void)
689 atomic_set(&throttle_percentage
, 0);
692 bool cpu_throttle_active(void)
694 return (cpu_throttle_get_percentage() != 0);
697 int cpu_throttle_get_percentage(void)
699 return atomic_read(&throttle_percentage
);
702 void cpu_ticks_init(void)
704 seqlock_init(&timers_state
.vm_clock_seqlock
);
705 vmstate_register(NULL
, 0, &vmstate_timers
, &timers_state
);
706 throttle_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL_RT
,
707 cpu_throttle_timer_tick
, NULL
);
710 void configure_icount(QemuOpts
*opts
, Error
**errp
)
713 char *rem_str
= NULL
;
715 option
= qemu_opt_get(opts
, "shift");
717 if (qemu_opt_get(opts
, "align") != NULL
) {
718 error_setg(errp
, "Please specify shift option when using align");
723 icount_sleep
= qemu_opt_get_bool(opts
, "sleep", true);
725 icount_warp_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL_RT
,
726 icount_timer_cb
, NULL
);
729 icount_align_option
= qemu_opt_get_bool(opts
, "align", false);
731 if (icount_align_option
&& !icount_sleep
) {
732 error_setg(errp
, "align=on and sleep=off are incompatible");
734 if (strcmp(option
, "auto") != 0) {
736 icount_time_shift
= strtol(option
, &rem_str
, 0);
737 if (errno
!= 0 || *rem_str
!= '\0' || !strlen(option
)) {
738 error_setg(errp
, "icount: Invalid shift value");
742 } else if (icount_align_option
) {
743 error_setg(errp
, "shift=auto and align=on are incompatible");
744 } else if (!icount_sleep
) {
745 error_setg(errp
, "shift=auto and sleep=off are incompatible");
750 /* 125MIPS seems a reasonable initial guess at the guest speed.
751 It will be corrected fairly quickly anyway. */
752 icount_time_shift
= 3;
754 /* Have both realtime and virtual time triggers for speed adjustment.
755 The realtime trigger catches emulated time passing too slowly,
756 the virtual time trigger catches emulated time passing too fast.
757 Realtime triggers occur even when idle, so use them less frequently
759 icount_rt_timer
= timer_new_ms(QEMU_CLOCK_VIRTUAL_RT
,
760 icount_adjust_rt
, NULL
);
761 timer_mod(icount_rt_timer
,
762 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT
) + 1000);
763 icount_vm_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
,
764 icount_adjust_vm
, NULL
);
765 timer_mod(icount_vm_timer
,
766 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) +
767 NANOSECONDS_PER_SECOND
/ 10);
770 /***********************************************************/
771 /* TCG vCPU kick timer
773 * The kick timer is responsible for moving single threaded vCPU
774 * emulation on to the next vCPU. If more than one vCPU is running a
775 * timer event with force a cpu->exit so the next vCPU can get
778 * The timer is removed if all vCPUs are idle and restarted again once
779 * idleness is complete.
782 static QEMUTimer
*tcg_kick_vcpu_timer
;
784 static void qemu_cpu_kick_no_halt(void);
786 #define TCG_KICK_PERIOD (NANOSECONDS_PER_SECOND / 10)
788 static inline int64_t qemu_tcg_next_kick(void)
790 return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) + TCG_KICK_PERIOD
;
793 static void kick_tcg_thread(void *opaque
)
795 timer_mod(tcg_kick_vcpu_timer
, qemu_tcg_next_kick());
796 qemu_cpu_kick_no_halt();
799 static void start_tcg_kick_timer(void)
801 if (!tcg_kick_vcpu_timer
&& CPU_NEXT(first_cpu
)) {
802 tcg_kick_vcpu_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
,
803 kick_tcg_thread
, NULL
);
804 timer_mod(tcg_kick_vcpu_timer
, qemu_tcg_next_kick());
808 static void stop_tcg_kick_timer(void)
810 if (tcg_kick_vcpu_timer
) {
811 timer_del(tcg_kick_vcpu_timer
);
812 tcg_kick_vcpu_timer
= NULL
;
817 /***********************************************************/
818 void hw_error(const char *fmt
, ...)
824 fprintf(stderr
, "qemu: hardware error: ");
825 vfprintf(stderr
, fmt
, ap
);
826 fprintf(stderr
, "\n");
828 fprintf(stderr
, "CPU #%d:\n", cpu
->cpu_index
);
829 cpu_dump_state(cpu
, stderr
, fprintf
, CPU_DUMP_FPU
);
835 void cpu_synchronize_all_states(void)
840 cpu_synchronize_state(cpu
);
844 void cpu_synchronize_all_post_reset(void)
849 cpu_synchronize_post_reset(cpu
);
853 void cpu_synchronize_all_post_init(void)
858 cpu_synchronize_post_init(cpu
);
862 static int do_vm_stop(RunState state
)
866 if (runstate_is_running()) {
870 vm_state_notify(0, state
);
871 qapi_event_send_stop(&error_abort
);
875 replay_disable_events();
876 ret
= bdrv_flush_all();
881 static bool cpu_can_run(CPUState
*cpu
)
886 if (cpu_is_stopped(cpu
)) {
892 static void cpu_handle_guest_debug(CPUState
*cpu
)
894 gdb_set_stop_cpu(cpu
);
895 qemu_system_debug_request();
900 static void sigbus_reraise(void)
903 struct sigaction action
;
905 memset(&action
, 0, sizeof(action
));
906 action
.sa_handler
= SIG_DFL
;
907 if (!sigaction(SIGBUS
, &action
, NULL
)) {
910 sigaddset(&set
, SIGBUS
);
911 pthread_sigmask(SIG_UNBLOCK
, &set
, NULL
);
913 perror("Failed to re-raise SIGBUS!\n");
917 static void sigbus_handler(int n
, struct qemu_signalfd_siginfo
*siginfo
,
920 if (kvm_on_sigbus(siginfo
->ssi_code
,
921 (void *)(intptr_t)siginfo
->ssi_addr
)) {
926 static void qemu_init_sigbus(void)
928 struct sigaction action
;
930 memset(&action
, 0, sizeof(action
));
931 action
.sa_flags
= SA_SIGINFO
;
932 action
.sa_sigaction
= (void (*)(int, siginfo_t
*, void*))sigbus_handler
;
933 sigaction(SIGBUS
, &action
, NULL
);
935 prctl(PR_MCE_KILL
, PR_MCE_KILL_SET
, PR_MCE_KILL_EARLY
, 0, 0);
938 static void qemu_kvm_eat_signals(CPUState
*cpu
)
940 struct timespec ts
= { 0, 0 };
946 sigemptyset(&waitset
);
947 sigaddset(&waitset
, SIG_IPI
);
948 sigaddset(&waitset
, SIGBUS
);
951 r
= sigtimedwait(&waitset
, &siginfo
, &ts
);
952 if (r
== -1 && !(errno
== EAGAIN
|| errno
== EINTR
)) {
953 perror("sigtimedwait");
959 if (kvm_on_sigbus_vcpu(cpu
, siginfo
.si_code
, siginfo
.si_addr
)) {
967 r
= sigpending(&chkset
);
969 perror("sigpending");
972 } while (sigismember(&chkset
, SIG_IPI
) || sigismember(&chkset
, SIGBUS
));
975 #else /* !CONFIG_LINUX */
977 static void qemu_init_sigbus(void)
981 static void qemu_kvm_eat_signals(CPUState
*cpu
)
984 #endif /* !CONFIG_LINUX */
987 static void dummy_signal(int sig
)
991 static void qemu_kvm_init_cpu_signals(CPUState
*cpu
)
995 struct sigaction sigact
;
997 memset(&sigact
, 0, sizeof(sigact
));
998 sigact
.sa_handler
= dummy_signal
;
999 sigaction(SIG_IPI
, &sigact
, NULL
);
1001 pthread_sigmask(SIG_BLOCK
, NULL
, &set
);
1002 sigdelset(&set
, SIG_IPI
);
1003 sigdelset(&set
, SIGBUS
);
1004 r
= kvm_set_signal_mask(cpu
, &set
);
1006 fprintf(stderr
, "kvm_set_signal_mask: %s\n", strerror(-r
));
1012 static void qemu_kvm_init_cpu_signals(CPUState
*cpu
)
1018 static QemuMutex qemu_global_mutex
;
1019 static QemuCond qemu_io_proceeded_cond
;
1020 static unsigned iothread_requesting_mutex
;
1022 static QemuThread io_thread
;
1025 static QemuCond qemu_cpu_cond
;
1027 static QemuCond qemu_pause_cond
;
1029 void qemu_init_cpu_loop(void)
1032 qemu_cond_init(&qemu_cpu_cond
);
1033 qemu_cond_init(&qemu_pause_cond
);
1034 qemu_cond_init(&qemu_io_proceeded_cond
);
1035 qemu_mutex_init(&qemu_global_mutex
);
1037 qemu_thread_get_self(&io_thread
);
1040 void run_on_cpu(CPUState
*cpu
, run_on_cpu_func func
, run_on_cpu_data data
)
1042 do_run_on_cpu(cpu
, func
, data
, &qemu_global_mutex
);
1045 static void qemu_kvm_destroy_vcpu(CPUState
*cpu
)
1047 if (kvm_destroy_vcpu(cpu
) < 0) {
1048 error_report("kvm_destroy_vcpu failed");
1053 static void qemu_tcg_destroy_vcpu(CPUState
*cpu
)
1057 static void qemu_wait_io_event_common(CPUState
*cpu
)
1061 cpu
->stopped
= true;
1062 qemu_cond_broadcast(&qemu_pause_cond
);
1064 process_queued_cpu_work(cpu
);
1065 cpu
->thread_kicked
= false;
1068 static void qemu_tcg_wait_io_event(CPUState
*cpu
)
1070 while (all_cpu_threads_idle()) {
1071 stop_tcg_kick_timer();
1072 qemu_cond_wait(cpu
->halt_cond
, &qemu_global_mutex
);
1075 start_tcg_kick_timer();
1077 while (iothread_requesting_mutex
) {
1078 qemu_cond_wait(&qemu_io_proceeded_cond
, &qemu_global_mutex
);
1082 qemu_wait_io_event_common(cpu
);
1086 static void qemu_kvm_wait_io_event(CPUState
*cpu
)
1088 while (cpu_thread_is_idle(cpu
)) {
1089 qemu_cond_wait(cpu
->halt_cond
, &qemu_global_mutex
);
1092 qemu_kvm_eat_signals(cpu
);
1093 qemu_wait_io_event_common(cpu
);
1096 static void *qemu_kvm_cpu_thread_fn(void *arg
)
1098 CPUState
*cpu
= arg
;
1101 rcu_register_thread();
1103 qemu_mutex_lock_iothread();
1104 qemu_thread_get_self(cpu
->thread
);
1105 cpu
->thread_id
= qemu_get_thread_id();
1109 r
= kvm_init_vcpu(cpu
);
1111 fprintf(stderr
, "kvm_init_vcpu failed: %s\n", strerror(-r
));
1115 qemu_kvm_init_cpu_signals(cpu
);
1117 /* signal CPU creation */
1118 cpu
->created
= true;
1119 qemu_cond_signal(&qemu_cpu_cond
);
1122 if (cpu_can_run(cpu
)) {
1123 r
= kvm_cpu_exec(cpu
);
1124 if (r
== EXCP_DEBUG
) {
1125 cpu_handle_guest_debug(cpu
);
1128 qemu_kvm_wait_io_event(cpu
);
1129 } while (!cpu
->unplug
|| cpu_can_run(cpu
));
1131 qemu_kvm_destroy_vcpu(cpu
);
1132 cpu
->created
= false;
1133 qemu_cond_signal(&qemu_cpu_cond
);
1134 qemu_mutex_unlock_iothread();
1138 static void *qemu_dummy_cpu_thread_fn(void *arg
)
1141 fprintf(stderr
, "qtest is not supported under Windows\n");
1144 CPUState
*cpu
= arg
;
1148 rcu_register_thread();
1150 qemu_mutex_lock_iothread();
1151 qemu_thread_get_self(cpu
->thread
);
1152 cpu
->thread_id
= qemu_get_thread_id();
1155 sigemptyset(&waitset
);
1156 sigaddset(&waitset
, SIG_IPI
);
1158 /* signal CPU creation */
1159 cpu
->created
= true;
1160 qemu_cond_signal(&qemu_cpu_cond
);
1165 qemu_mutex_unlock_iothread();
1168 r
= sigwait(&waitset
, &sig
);
1169 } while (r
== -1 && (errno
== EAGAIN
|| errno
== EINTR
));
1174 qemu_mutex_lock_iothread();
1176 qemu_wait_io_event_common(cpu
);
1183 static int64_t tcg_get_icount_limit(void)
1187 if (replay_mode
!= REPLAY_MODE_PLAY
) {
1188 deadline
= qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL
);
1190 /* Maintain prior (possibly buggy) behaviour where if no deadline
1191 * was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than
1192 * INT32_MAX nanoseconds ahead, we still use INT32_MAX
1195 if ((deadline
< 0) || (deadline
> INT32_MAX
)) {
1196 deadline
= INT32_MAX
;
1199 return qemu_icount_round(deadline
);
1201 return replay_get_instructions();
1205 static void handle_icount_deadline(void)
1209 qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL
);
1211 if (deadline
== 0) {
1212 qemu_clock_notify(QEMU_CLOCK_VIRTUAL
);
1217 static int tcg_cpu_exec(CPUState
*cpu
)
1220 #ifdef CONFIG_PROFILER
1224 #ifdef CONFIG_PROFILER
1225 ti
= profile_getclock();
1230 timers_state
.qemu_icount
-= (cpu
->icount_decr
.u16
.low
1231 + cpu
->icount_extra
);
1232 cpu
->icount_decr
.u16
.low
= 0;
1233 cpu
->icount_extra
= 0;
1234 count
= tcg_get_icount_limit();
1235 timers_state
.qemu_icount
+= count
;
1236 decr
= (count
> 0xffff) ? 0xffff : count
;
1238 cpu
->icount_decr
.u16
.low
= decr
;
1239 cpu
->icount_extra
= count
;
1241 cpu_exec_start(cpu
);
1242 ret
= cpu_exec(cpu
);
1244 #ifdef CONFIG_PROFILER
1245 tcg_time
+= profile_getclock() - ti
;
1248 /* Fold pending instructions back into the
1249 instruction counter, and clear the interrupt flag. */
1250 timers_state
.qemu_icount
-= (cpu
->icount_decr
.u16
.low
1251 + cpu
->icount_extra
);
1252 cpu
->icount_decr
.u32
= 0;
1253 cpu
->icount_extra
= 0;
1254 replay_account_executed_instructions();
1259 /* Destroy any remaining vCPUs which have been unplugged and have
1262 static void deal_with_unplugged_cpus(void)
1267 if (cpu
->unplug
&& !cpu_can_run(cpu
)) {
1268 qemu_tcg_destroy_vcpu(cpu
);
1269 cpu
->created
= false;
1270 qemu_cond_signal(&qemu_cpu_cond
);
1276 /* Single-threaded TCG
1278 * In the single-threaded case each vCPU is simulated in turn. If
1279 * there is more than a single vCPU we create a simple timer to kick
1280 * the vCPU and ensure we don't get stuck in a tight loop in one vCPU.
1281 * This is done explicitly rather than relying on side-effects
1285 static void *qemu_tcg_cpu_thread_fn(void *arg
)
1287 CPUState
*cpu
= arg
;
1289 rcu_register_thread();
1291 qemu_mutex_lock_iothread();
1292 qemu_thread_get_self(cpu
->thread
);
1295 cpu
->thread_id
= qemu_get_thread_id();
1296 cpu
->created
= true;
1299 qemu_cond_signal(&qemu_cpu_cond
);
1301 /* wait for initial kick-off after machine start */
1302 while (first_cpu
->stopped
) {
1303 qemu_cond_wait(first_cpu
->halt_cond
, &qemu_global_mutex
);
1305 /* process any pending work */
1307 qemu_wait_io_event_common(cpu
);
1311 start_tcg_kick_timer();
1313 /* process any pending work */
1314 atomic_mb_set(&exit_request
, 1);
1319 /* Account partial waits to QEMU_CLOCK_VIRTUAL. */
1320 qemu_account_warp_timer();
1326 for (; cpu
!= NULL
&& !exit_request
; cpu
= CPU_NEXT(cpu
)) {
1328 qemu_clock_enable(QEMU_CLOCK_VIRTUAL
,
1329 (cpu
->singlestep_enabled
& SSTEP_NOTIMER
) == 0);
1331 if (cpu_can_run(cpu
)) {
1333 r
= tcg_cpu_exec(cpu
);
1334 if (r
== EXCP_DEBUG
) {
1335 cpu_handle_guest_debug(cpu
);
1338 } else if (cpu
->stop
|| cpu
->stopped
) {
1340 cpu
= CPU_NEXT(cpu
);
1347 /* Pairs with smp_wmb in qemu_cpu_kick. */
1348 atomic_mb_set(&exit_request
, 0);
1350 handle_icount_deadline();
1352 qemu_tcg_wait_io_event(QTAILQ_FIRST(&cpus
));
1353 deal_with_unplugged_cpus();
1359 static void *qemu_hax_cpu_thread_fn(void *arg
)
1361 CPUState
*cpu
= arg
;
1363 qemu_thread_get_self(cpu
->thread
);
1364 qemu_mutex_lock(&qemu_global_mutex
);
1366 cpu
->thread_id
= qemu_get_thread_id();
1367 cpu
->created
= true;
1372 qemu_cond_signal(&qemu_cpu_cond
);
1375 if (cpu_can_run(cpu
)) {
1376 r
= hax_smp_cpu_exec(cpu
);
1377 if (r
== EXCP_DEBUG
) {
1378 cpu_handle_guest_debug(cpu
);
1382 while (cpu_thread_is_idle(cpu
)) {
1383 qemu_cond_wait(cpu
->halt_cond
, &qemu_global_mutex
);
1388 qemu_wait_io_event_common(cpu
);
1394 static void CALLBACK
dummy_apc_func(ULONG_PTR unused
)
1399 static void qemu_cpu_kick_thread(CPUState
*cpu
)
1404 if (cpu
->thread_kicked
) {
1407 cpu
->thread_kicked
= true;
1408 err
= pthread_kill(cpu
->thread
->thread
, SIG_IPI
);
1410 fprintf(stderr
, "qemu:%s: %s", __func__
, strerror(err
));
1414 if (!qemu_cpu_is_self(cpu
)) {
1415 if (!QueueUserAPC(dummy_apc_func
, cpu
->hThread
, 0)) {
1416 fprintf(stderr
, "%s: QueueUserAPC failed with error %lu\n",
1417 __func__
, GetLastError());
1424 static void qemu_cpu_kick_no_halt(void)
1427 /* Ensure whatever caused the exit has reached the CPU threads before
1428 * writing exit_request.
1430 atomic_mb_set(&exit_request
, 1);
1431 cpu
= atomic_mb_read(&tcg_current_cpu
);
1437 void qemu_cpu_kick(CPUState
*cpu
)
1439 qemu_cond_broadcast(cpu
->halt_cond
);
1440 if (tcg_enabled()) {
1441 qemu_cpu_kick_no_halt();
1443 if (hax_enabled()) {
1445 * FIXME: race condition with the exit_request check in
1448 cpu
->exit_request
= 1;
1450 qemu_cpu_kick_thread(cpu
);
1454 void qemu_cpu_kick_self(void)
1456 assert(current_cpu
);
1457 qemu_cpu_kick_thread(current_cpu
);
1460 bool qemu_cpu_is_self(CPUState
*cpu
)
1462 return qemu_thread_is_self(cpu
->thread
);
1465 bool qemu_in_vcpu_thread(void)
1467 return current_cpu
&& qemu_cpu_is_self(current_cpu
);
1470 static __thread
bool iothread_locked
= false;
1472 bool qemu_mutex_iothread_locked(void)
1474 return iothread_locked
;
1477 void qemu_mutex_lock_iothread(void)
1479 atomic_inc(&iothread_requesting_mutex
);
1480 /* In the simple case there is no need to bump the VCPU thread out of
1481 * TCG code execution.
1483 if (!tcg_enabled() || qemu_in_vcpu_thread() ||
1484 !first_cpu
|| !first_cpu
->created
) {
1485 qemu_mutex_lock(&qemu_global_mutex
);
1486 atomic_dec(&iothread_requesting_mutex
);
1488 if (qemu_mutex_trylock(&qemu_global_mutex
)) {
1489 qemu_cpu_kick_no_halt();
1490 qemu_mutex_lock(&qemu_global_mutex
);
1492 atomic_dec(&iothread_requesting_mutex
);
1493 qemu_cond_broadcast(&qemu_io_proceeded_cond
);
1495 iothread_locked
= true;
1498 void qemu_mutex_unlock_iothread(void)
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()) {
1529 if (!kvm_enabled()) {
1532 cpu
->stopped
= true;
1538 while (!all_vcpus_paused()) {
1539 qemu_cond_wait(&qemu_pause_cond
, &qemu_global_mutex
);
1546 void cpu_resume(CPUState
*cpu
)
1549 cpu
->stopped
= false;
1553 void resume_all_vcpus(void)
1557 qemu_clock_enable(QEMU_CLOCK_VIRTUAL
, true);
1563 void cpu_remove(CPUState
*cpu
)
1570 void cpu_remove_sync(CPUState
*cpu
)
1573 while (cpu
->created
) {
1574 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1578 /* For temporary buffers for forming a name */
1579 #define VCPU_THREAD_NAME_SIZE 16
1581 static void qemu_tcg_init_vcpu(CPUState
*cpu
)
1583 char thread_name
[VCPU_THREAD_NAME_SIZE
];
1584 static QemuCond
*tcg_halt_cond
;
1585 static QemuThread
*tcg_cpu_thread
;
1587 /* share a single thread for all cpus with TCG */
1588 if (!tcg_cpu_thread
) {
1589 cpu
->thread
= g_malloc0(sizeof(QemuThread
));
1590 cpu
->halt_cond
= g_malloc0(sizeof(QemuCond
));
1591 qemu_cond_init(cpu
->halt_cond
);
1592 tcg_halt_cond
= cpu
->halt_cond
;
1593 snprintf(thread_name
, VCPU_THREAD_NAME_SIZE
, "CPU %d/TCG",
1595 qemu_thread_create(cpu
->thread
, thread_name
, qemu_tcg_cpu_thread_fn
,
1596 cpu
, QEMU_THREAD_JOINABLE
);
1598 cpu
->hThread
= qemu_thread_get_handle(cpu
->thread
);
1600 while (!cpu
->created
) {
1601 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1603 tcg_cpu_thread
= cpu
->thread
;
1605 cpu
->thread
= tcg_cpu_thread
;
1606 cpu
->halt_cond
= tcg_halt_cond
;
1610 static void qemu_hax_start_vcpu(CPUState
*cpu
)
1612 char thread_name
[VCPU_THREAD_NAME_SIZE
];
1614 cpu
->thread
= g_malloc0(sizeof(QemuThread
));
1615 cpu
->halt_cond
= g_malloc0(sizeof(QemuCond
));
1616 qemu_cond_init(cpu
->halt_cond
);
1618 snprintf(thread_name
, VCPU_THREAD_NAME_SIZE
, "CPU %d/HAX",
1620 qemu_thread_create(cpu
->thread
, thread_name
, qemu_hax_cpu_thread_fn
,
1621 cpu
, QEMU_THREAD_JOINABLE
);
1623 cpu
->hThread
= qemu_thread_get_handle(cpu
->thread
);
1625 while (!cpu
->created
) {
1626 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1630 static void qemu_kvm_start_vcpu(CPUState
*cpu
)
1632 char thread_name
[VCPU_THREAD_NAME_SIZE
];
1634 cpu
->thread
= g_malloc0(sizeof(QemuThread
));
1635 cpu
->halt_cond
= g_malloc0(sizeof(QemuCond
));
1636 qemu_cond_init(cpu
->halt_cond
);
1637 snprintf(thread_name
, VCPU_THREAD_NAME_SIZE
, "CPU %d/KVM",
1639 qemu_thread_create(cpu
->thread
, thread_name
, qemu_kvm_cpu_thread_fn
,
1640 cpu
, QEMU_THREAD_JOINABLE
);
1641 while (!cpu
->created
) {
1642 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1646 static void qemu_dummy_start_vcpu(CPUState
*cpu
)
1648 char thread_name
[VCPU_THREAD_NAME_SIZE
];
1650 cpu
->thread
= g_malloc0(sizeof(QemuThread
));
1651 cpu
->halt_cond
= g_malloc0(sizeof(QemuCond
));
1652 qemu_cond_init(cpu
->halt_cond
);
1653 snprintf(thread_name
, VCPU_THREAD_NAME_SIZE
, "CPU %d/DUMMY",
1655 qemu_thread_create(cpu
->thread
, thread_name
, qemu_dummy_cpu_thread_fn
, cpu
,
1656 QEMU_THREAD_JOINABLE
);
1657 while (!cpu
->created
) {
1658 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1662 void qemu_init_vcpu(CPUState
*cpu
)
1664 cpu
->nr_cores
= smp_cores
;
1665 cpu
->nr_threads
= smp_threads
;
1666 cpu
->stopped
= true;
1669 /* If the target cpu hasn't set up any address spaces itself,
1670 * give it the default one.
1672 AddressSpace
*as
= address_space_init_shareable(cpu
->memory
,
1675 cpu_address_space_init(cpu
, as
, 0);
1678 if (kvm_enabled()) {
1679 qemu_kvm_start_vcpu(cpu
);
1680 } else if (hax_enabled()) {
1681 qemu_hax_start_vcpu(cpu
);
1682 } else if (tcg_enabled()) {
1683 qemu_tcg_init_vcpu(cpu
);
1685 qemu_dummy_start_vcpu(cpu
);
1689 void cpu_stop_current(void)
1692 current_cpu
->stop
= false;
1693 current_cpu
->stopped
= true;
1694 cpu_exit(current_cpu
);
1695 qemu_cond_broadcast(&qemu_pause_cond
);
1699 int vm_stop(RunState state
)
1701 if (qemu_in_vcpu_thread()) {
1702 qemu_system_vmstop_request_prepare();
1703 qemu_system_vmstop_request(state
);
1705 * FIXME: should not return to device code in case
1706 * vm_stop() has been requested.
1712 return do_vm_stop(state
);
1716 * Prepare for (re)starting the VM.
1717 * Returns -1 if the vCPUs are not to be restarted (e.g. if they are already
1718 * running or in case of an error condition), 0 otherwise.
1720 int vm_prepare_start(void)
1725 qemu_vmstop_requested(&requested
);
1726 if (runstate_is_running() && requested
== RUN_STATE__MAX
) {
1730 /* Ensure that a STOP/RESUME pair of events is emitted if a
1731 * vmstop request was pending. The BLOCK_IO_ERROR event, for
1732 * example, according to documentation is always followed by
1735 if (runstate_is_running()) {
1736 qapi_event_send_stop(&error_abort
);
1739 replay_enable_events();
1741 runstate_set(RUN_STATE_RUNNING
);
1742 vm_state_notify(1, RUN_STATE_RUNNING
);
1745 /* We are sending this now, but the CPUs will be resumed shortly later */
1746 qapi_event_send_resume(&error_abort
);
1752 if (!vm_prepare_start()) {
1757 /* does a state transition even if the VM is already stopped,
1758 current state is forgotten forever */
1759 int vm_stop_force_state(RunState state
)
1761 if (runstate_is_running()) {
1762 return vm_stop(state
);
1764 runstate_set(state
);
1767 /* Make sure to return an error if the flush in a previous vm_stop()
1769 return bdrv_flush_all();
1773 void list_cpus(FILE *f
, fprintf_function cpu_fprintf
, const char *optarg
)
1775 /* XXX: implement xxx_cpu_list for targets that still miss it */
1776 #if defined(cpu_list)
1777 cpu_list(f
, cpu_fprintf
);
1781 CpuInfoList
*qmp_query_cpus(Error
**errp
)
1783 CpuInfoList
*head
= NULL
, *cur_item
= NULL
;
1788 #if defined(TARGET_I386)
1789 X86CPU
*x86_cpu
= X86_CPU(cpu
);
1790 CPUX86State
*env
= &x86_cpu
->env
;
1791 #elif defined(TARGET_PPC)
1792 PowerPCCPU
*ppc_cpu
= POWERPC_CPU(cpu
);
1793 CPUPPCState
*env
= &ppc_cpu
->env
;
1794 #elif defined(TARGET_SPARC)
1795 SPARCCPU
*sparc_cpu
= SPARC_CPU(cpu
);
1796 CPUSPARCState
*env
= &sparc_cpu
->env
;
1797 #elif defined(TARGET_MIPS)
1798 MIPSCPU
*mips_cpu
= MIPS_CPU(cpu
);
1799 CPUMIPSState
*env
= &mips_cpu
->env
;
1800 #elif defined(TARGET_TRICORE)
1801 TriCoreCPU
*tricore_cpu
= TRICORE_CPU(cpu
);
1802 CPUTriCoreState
*env
= &tricore_cpu
->env
;
1805 cpu_synchronize_state(cpu
);
1807 info
= g_malloc0(sizeof(*info
));
1808 info
->value
= g_malloc0(sizeof(*info
->value
));
1809 info
->value
->CPU
= cpu
->cpu_index
;
1810 info
->value
->current
= (cpu
== first_cpu
);
1811 info
->value
->halted
= cpu
->halted
;
1812 info
->value
->qom_path
= object_get_canonical_path(OBJECT(cpu
));
1813 info
->value
->thread_id
= cpu
->thread_id
;
1814 #if defined(TARGET_I386)
1815 info
->value
->arch
= CPU_INFO_ARCH_X86
;
1816 info
->value
->u
.x86
.pc
= env
->eip
+ env
->segs
[R_CS
].base
;
1817 #elif defined(TARGET_PPC)
1818 info
->value
->arch
= CPU_INFO_ARCH_PPC
;
1819 info
->value
->u
.ppc
.nip
= env
->nip
;
1820 #elif defined(TARGET_SPARC)
1821 info
->value
->arch
= CPU_INFO_ARCH_SPARC
;
1822 info
->value
->u
.q_sparc
.pc
= env
->pc
;
1823 info
->value
->u
.q_sparc
.npc
= env
->npc
;
1824 #elif defined(TARGET_MIPS)
1825 info
->value
->arch
= CPU_INFO_ARCH_MIPS
;
1826 info
->value
->u
.q_mips
.PC
= env
->active_tc
.PC
;
1827 #elif defined(TARGET_TRICORE)
1828 info
->value
->arch
= CPU_INFO_ARCH_TRICORE
;
1829 info
->value
->u
.tricore
.PC
= env
->PC
;
1831 info
->value
->arch
= CPU_INFO_ARCH_OTHER
;
1834 /* XXX: waiting for the qapi to support GSList */
1836 head
= cur_item
= info
;
1838 cur_item
->next
= info
;
1846 void qmp_memsave(int64_t addr
, int64_t size
, const char *filename
,
1847 bool has_cpu
, int64_t cpu_index
, Error
**errp
)
1853 int64_t orig_addr
= addr
, orig_size
= size
;
1859 cpu
= qemu_get_cpu(cpu_index
);
1861 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "cpu-index",
1866 f
= fopen(filename
, "wb");
1868 error_setg_file_open(errp
, errno
, filename
);
1876 if (cpu_memory_rw_debug(cpu
, addr
, buf
, l
, 0) != 0) {
1877 error_setg(errp
, "Invalid addr 0x%016" PRIx64
"/size %" PRId64
1878 " specified", orig_addr
, orig_size
);
1881 if (fwrite(buf
, 1, l
, f
) != l
) {
1882 error_setg(errp
, QERR_IO_ERROR
);
1893 void qmp_pmemsave(int64_t addr
, int64_t size
, const char *filename
,
1900 f
= fopen(filename
, "wb");
1902 error_setg_file_open(errp
, errno
, filename
);
1910 cpu_physical_memory_read(addr
, buf
, l
);
1911 if (fwrite(buf
, 1, l
, f
) != l
) {
1912 error_setg(errp
, QERR_IO_ERROR
);
1923 void qmp_inject_nmi(Error
**errp
)
1925 nmi_monitor_handle(monitor_get_cpu_index(), errp
);
1928 void dump_drift_info(FILE *f
, fprintf_function cpu_fprintf
)
1934 cpu_fprintf(f
, "Host - Guest clock %"PRIi64
" ms\n",
1935 (cpu_get_clock() - cpu_get_icount())/SCALE_MS
);
1936 if (icount_align_option
) {
1937 cpu_fprintf(f
, "Max guest delay %"PRIi64
" ms\n", -max_delay
/SCALE_MS
);
1938 cpu_fprintf(f
, "Max guest advance %"PRIi64
" ms\n", max_advance
/SCALE_MS
);
1940 cpu_fprintf(f
, "Max guest delay NA\n");
1941 cpu_fprintf(f
, "Max guest advance NA\n");