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 "config-host.h"
33 #include "qmp-commands.h"
35 #include "qemu-thread.h"
38 #include "main-loop.h"
47 #include <sys/prctl.h>
50 #define PR_MCE_KILL 33
53 #ifndef PR_MCE_KILL_SET
54 #define PR_MCE_KILL_SET 1
57 #ifndef PR_MCE_KILL_EARLY
58 #define PR_MCE_KILL_EARLY 1
61 #endif /* CONFIG_LINUX */
63 static CPUArchState
*next_cpu
;
65 static bool cpu_thread_is_idle(CPUArchState
*env
)
67 if (env
->stop
|| env
->queued_work_first
) {
70 if (env
->stopped
|| !runstate_is_running()) {
73 if (!env
->halted
|| qemu_cpu_has_work(env
) ||
74 kvm_async_interrupts_enabled()) {
80 static bool all_cpu_threads_idle(void)
84 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
85 if (!cpu_thread_is_idle(env
)) {
92 /***********************************************************/
93 /* guest cycle counter */
95 /* Conversion factor from emulated instructions to virtual clock ticks. */
96 static int icount_time_shift
;
97 /* Arbitrarily pick 1MIPS as the minimum allowable speed. */
98 #define MAX_ICOUNT_SHIFT 10
99 /* Compensate for varying guest execution speed. */
100 static int64_t qemu_icount_bias
;
101 static QEMUTimer
*icount_rt_timer
;
102 static QEMUTimer
*icount_vm_timer
;
103 static QEMUTimer
*icount_warp_timer
;
104 static int64_t vm_clock_warp_start
;
105 static int64_t qemu_icount
;
107 typedef struct TimersState
{
108 int64_t cpu_ticks_prev
;
109 int64_t cpu_ticks_offset
;
110 int64_t cpu_clock_offset
;
111 int32_t cpu_ticks_enabled
;
115 TimersState timers_state
;
117 /* Return the virtual CPU time, based on the instruction counter. */
118 int64_t cpu_get_icount(void)
121 CPUArchState
*env
= cpu_single_env
;
123 icount
= qemu_icount
;
125 if (!can_do_io(env
)) {
126 fprintf(stderr
, "Bad clock read\n");
128 icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
130 return qemu_icount_bias
+ (icount
<< icount_time_shift
);
133 /* return the host CPU cycle counter and handle stop/restart */
134 int64_t cpu_get_ticks(void)
137 return cpu_get_icount();
139 if (!timers_state
.cpu_ticks_enabled
) {
140 return timers_state
.cpu_ticks_offset
;
143 ticks
= cpu_get_real_ticks();
144 if (timers_state
.cpu_ticks_prev
> ticks
) {
145 /* Note: non increasing ticks may happen if the host uses
147 timers_state
.cpu_ticks_offset
+= timers_state
.cpu_ticks_prev
- ticks
;
149 timers_state
.cpu_ticks_prev
= ticks
;
150 return ticks
+ timers_state
.cpu_ticks_offset
;
154 /* return the host CPU monotonic timer and handle stop/restart */
155 int64_t cpu_get_clock(void)
158 if (!timers_state
.cpu_ticks_enabled
) {
159 return timers_state
.cpu_clock_offset
;
162 return ti
+ timers_state
.cpu_clock_offset
;
166 /* enable cpu_get_ticks() */
167 void cpu_enable_ticks(void)
169 if (!timers_state
.cpu_ticks_enabled
) {
170 timers_state
.cpu_ticks_offset
-= cpu_get_real_ticks();
171 timers_state
.cpu_clock_offset
-= get_clock();
172 timers_state
.cpu_ticks_enabled
= 1;
176 /* disable cpu_get_ticks() : the clock is stopped. You must not call
177 cpu_get_ticks() after that. */
178 void cpu_disable_ticks(void)
180 if (timers_state
.cpu_ticks_enabled
) {
181 timers_state
.cpu_ticks_offset
= cpu_get_ticks();
182 timers_state
.cpu_clock_offset
= cpu_get_clock();
183 timers_state
.cpu_ticks_enabled
= 0;
187 /* Correlation between real and virtual time is always going to be
188 fairly approximate, so ignore small variation.
189 When the guest is idle real and virtual time will be aligned in
191 #define ICOUNT_WOBBLE (get_ticks_per_sec() / 10)
193 static void icount_adjust(void)
198 static int64_t last_delta
;
199 /* If the VM is not running, then do nothing. */
200 if (!runstate_is_running()) {
203 cur_time
= cpu_get_clock();
204 cur_icount
= qemu_get_clock_ns(vm_clock
);
205 delta
= cur_icount
- cur_time
;
206 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
208 && last_delta
+ ICOUNT_WOBBLE
< delta
* 2
209 && icount_time_shift
> 0) {
210 /* The guest is getting too far ahead. Slow time down. */
214 && last_delta
- ICOUNT_WOBBLE
> delta
* 2
215 && icount_time_shift
< MAX_ICOUNT_SHIFT
) {
216 /* The guest is getting too far behind. Speed time up. */
220 qemu_icount_bias
= cur_icount
- (qemu_icount
<< icount_time_shift
);
223 static void icount_adjust_rt(void *opaque
)
225 qemu_mod_timer(icount_rt_timer
,
226 qemu_get_clock_ms(rt_clock
) + 1000);
230 static void icount_adjust_vm(void *opaque
)
232 qemu_mod_timer(icount_vm_timer
,
233 qemu_get_clock_ns(vm_clock
) + get_ticks_per_sec() / 10);
237 static int64_t qemu_icount_round(int64_t count
)
239 return (count
+ (1 << icount_time_shift
) - 1) >> icount_time_shift
;
242 static void icount_warp_rt(void *opaque
)
244 if (vm_clock_warp_start
== -1) {
248 if (runstate_is_running()) {
249 int64_t clock
= qemu_get_clock_ns(rt_clock
);
250 int64_t warp_delta
= clock
- vm_clock_warp_start
;
251 if (use_icount
== 1) {
252 qemu_icount_bias
+= warp_delta
;
255 * In adaptive mode, do not let the vm_clock run too
256 * far ahead of real time.
258 int64_t cur_time
= cpu_get_clock();
259 int64_t cur_icount
= qemu_get_clock_ns(vm_clock
);
260 int64_t delta
= cur_time
- cur_icount
;
261 qemu_icount_bias
+= MIN(warp_delta
, delta
);
263 if (qemu_clock_expired(vm_clock
)) {
267 vm_clock_warp_start
= -1;
270 void qtest_clock_warp(int64_t dest
)
272 int64_t clock
= qemu_get_clock_ns(vm_clock
);
273 assert(qtest_enabled());
274 while (clock
< dest
) {
275 int64_t deadline
= qemu_clock_deadline(vm_clock
);
276 int64_t warp
= MIN(dest
- clock
, deadline
);
277 qemu_icount_bias
+= warp
;
278 qemu_run_timers(vm_clock
);
279 clock
= qemu_get_clock_ns(vm_clock
);
284 void qemu_clock_warp(QEMUClock
*clock
)
289 * There are too many global variables to make the "warp" behavior
290 * applicable to other clocks. But a clock argument removes the
291 * need for if statements all over the place.
293 if (clock
!= vm_clock
|| !use_icount
) {
298 * If the CPUs have been sleeping, advance the vm_clock timer now. This
299 * ensures that the deadline for the timer is computed correctly below.
300 * This also makes sure that the insn counter is synchronized before the
301 * CPU starts running, in case the CPU is woken by an event other than
302 * the earliest vm_clock timer.
304 icount_warp_rt(NULL
);
305 if (!all_cpu_threads_idle() || !qemu_clock_has_timers(vm_clock
)) {
306 qemu_del_timer(icount_warp_timer
);
310 if (qtest_enabled()) {
311 /* When testing, qtest commands advance icount. */
315 vm_clock_warp_start
= qemu_get_clock_ns(rt_clock
);
316 deadline
= qemu_clock_deadline(vm_clock
);
319 * Ensure the vm_clock proceeds even when the virtual CPU goes to
320 * sleep. Otherwise, the CPU might be waiting for a future timer
321 * interrupt to wake it up, but the interrupt never comes because
322 * the vCPU isn't running any insns and thus doesn't advance the
325 * An extreme solution for this problem would be to never let VCPUs
326 * sleep in icount mode if there is a pending vm_clock timer; rather
327 * time could just advance to the next vm_clock event. Instead, we
328 * do stop VCPUs and only advance vm_clock after some "real" time,
329 * (related to the time left until the next event) has passed. This
330 * rt_clock timer will do this. This avoids that the warps are too
331 * visible externally---for example, you will not be sending network
332 * packets continuously instead of every 100ms.
334 qemu_mod_timer(icount_warp_timer
, vm_clock_warp_start
+ deadline
);
340 static const VMStateDescription vmstate_timers
= {
343 .minimum_version_id
= 1,
344 .minimum_version_id_old
= 1,
345 .fields
= (VMStateField
[]) {
346 VMSTATE_INT64(cpu_ticks_offset
, TimersState
),
347 VMSTATE_INT64(dummy
, TimersState
),
348 VMSTATE_INT64_V(cpu_clock_offset
, TimersState
, 2),
349 VMSTATE_END_OF_LIST()
353 void configure_icount(const char *option
)
355 vmstate_register(NULL
, 0, &vmstate_timers
, &timers_state
);
360 icount_warp_timer
= qemu_new_timer_ns(rt_clock
, icount_warp_rt
, NULL
);
361 if (strcmp(option
, "auto") != 0) {
362 icount_time_shift
= strtol(option
, NULL
, 0);
369 /* 125MIPS seems a reasonable initial guess at the guest speed.
370 It will be corrected fairly quickly anyway. */
371 icount_time_shift
= 3;
373 /* Have both realtime and virtual time triggers for speed adjustment.
374 The realtime trigger catches emulated time passing too slowly,
375 the virtual time trigger catches emulated time passing too fast.
376 Realtime triggers occur even when idle, so use them less frequently
378 icount_rt_timer
= qemu_new_timer_ms(rt_clock
, icount_adjust_rt
, NULL
);
379 qemu_mod_timer(icount_rt_timer
,
380 qemu_get_clock_ms(rt_clock
) + 1000);
381 icount_vm_timer
= qemu_new_timer_ns(vm_clock
, icount_adjust_vm
, NULL
);
382 qemu_mod_timer(icount_vm_timer
,
383 qemu_get_clock_ns(vm_clock
) + get_ticks_per_sec() / 10);
386 /***********************************************************/
387 void hw_error(const char *fmt
, ...)
393 fprintf(stderr
, "qemu: hardware error: ");
394 vfprintf(stderr
, fmt
, ap
);
395 fprintf(stderr
, "\n");
396 for(env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
397 fprintf(stderr
, "CPU #%d:\n", env
->cpu_index
);
398 cpu_dump_state(env
, stderr
, fprintf
, CPU_DUMP_FPU
);
404 void cpu_synchronize_all_states(void)
408 for (cpu
= first_cpu
; cpu
; cpu
= cpu
->next_cpu
) {
409 cpu_synchronize_state(cpu
);
413 void cpu_synchronize_all_post_reset(void)
417 for (cpu
= first_cpu
; cpu
; cpu
= cpu
->next_cpu
) {
418 cpu_synchronize_post_reset(cpu
);
422 void cpu_synchronize_all_post_init(void)
426 for (cpu
= first_cpu
; cpu
; cpu
= cpu
->next_cpu
) {
427 cpu_synchronize_post_init(cpu
);
431 int cpu_is_stopped(CPUArchState
*env
)
433 return !runstate_is_running() || env
->stopped
;
436 static void do_vm_stop(RunState state
)
438 if (runstate_is_running()) {
442 vm_state_notify(0, state
);
445 monitor_protocol_event(QEVENT_STOP
, NULL
);
449 static int cpu_can_run(CPUArchState
*env
)
454 if (env
->stopped
|| !runstate_is_running()) {
460 static void cpu_handle_guest_debug(CPUArchState
*env
)
462 gdb_set_stop_cpu(env
);
463 qemu_system_debug_request();
467 static void cpu_signal(int sig
)
469 if (cpu_single_env
) {
470 cpu_exit(cpu_single_env
);
476 static void sigbus_reraise(void)
479 struct sigaction action
;
481 memset(&action
, 0, sizeof(action
));
482 action
.sa_handler
= SIG_DFL
;
483 if (!sigaction(SIGBUS
, &action
, NULL
)) {
486 sigaddset(&set
, SIGBUS
);
487 sigprocmask(SIG_UNBLOCK
, &set
, NULL
);
489 perror("Failed to re-raise SIGBUS!\n");
493 static void sigbus_handler(int n
, struct qemu_signalfd_siginfo
*siginfo
,
496 if (kvm_on_sigbus(siginfo
->ssi_code
,
497 (void *)(intptr_t)siginfo
->ssi_addr
)) {
502 static void qemu_init_sigbus(void)
504 struct sigaction action
;
506 memset(&action
, 0, sizeof(action
));
507 action
.sa_flags
= SA_SIGINFO
;
508 action
.sa_sigaction
= (void (*)(int, siginfo_t
*, void*))sigbus_handler
;
509 sigaction(SIGBUS
, &action
, NULL
);
511 prctl(PR_MCE_KILL
, PR_MCE_KILL_SET
, PR_MCE_KILL_EARLY
, 0, 0);
514 static void qemu_kvm_eat_signals(CPUArchState
*env
)
516 struct timespec ts
= { 0, 0 };
522 sigemptyset(&waitset
);
523 sigaddset(&waitset
, SIG_IPI
);
524 sigaddset(&waitset
, SIGBUS
);
527 r
= sigtimedwait(&waitset
, &siginfo
, &ts
);
528 if (r
== -1 && !(errno
== EAGAIN
|| errno
== EINTR
)) {
529 perror("sigtimedwait");
535 if (kvm_on_sigbus_vcpu(env
, siginfo
.si_code
, siginfo
.si_addr
)) {
543 r
= sigpending(&chkset
);
545 perror("sigpending");
548 } while (sigismember(&chkset
, SIG_IPI
) || sigismember(&chkset
, SIGBUS
));
551 #else /* !CONFIG_LINUX */
553 static void qemu_init_sigbus(void)
557 static void qemu_kvm_eat_signals(CPUArchState
*env
)
560 #endif /* !CONFIG_LINUX */
563 static void dummy_signal(int sig
)
567 static void qemu_kvm_init_cpu_signals(CPUArchState
*env
)
571 struct sigaction sigact
;
573 memset(&sigact
, 0, sizeof(sigact
));
574 sigact
.sa_handler
= dummy_signal
;
575 sigaction(SIG_IPI
, &sigact
, NULL
);
577 pthread_sigmask(SIG_BLOCK
, NULL
, &set
);
578 sigdelset(&set
, SIG_IPI
);
579 sigdelset(&set
, SIGBUS
);
580 r
= kvm_set_signal_mask(env
, &set
);
582 fprintf(stderr
, "kvm_set_signal_mask: %s\n", strerror(-r
));
587 static void qemu_tcg_init_cpu_signals(void)
590 struct sigaction sigact
;
592 memset(&sigact
, 0, sizeof(sigact
));
593 sigact
.sa_handler
= cpu_signal
;
594 sigaction(SIG_IPI
, &sigact
, NULL
);
597 sigaddset(&set
, SIG_IPI
);
598 pthread_sigmask(SIG_UNBLOCK
, &set
, NULL
);
602 static void qemu_kvm_init_cpu_signals(CPUArchState
*env
)
607 static void qemu_tcg_init_cpu_signals(void)
612 static QemuMutex qemu_global_mutex
;
613 static QemuCond qemu_io_proceeded_cond
;
614 static bool iothread_requesting_mutex
;
616 static QemuThread io_thread
;
618 static QemuThread
*tcg_cpu_thread
;
619 static QemuCond
*tcg_halt_cond
;
622 static QemuCond qemu_cpu_cond
;
624 static QemuCond qemu_pause_cond
;
625 static QemuCond qemu_work_cond
;
627 void qemu_init_cpu_loop(void)
630 qemu_cond_init(&qemu_cpu_cond
);
631 qemu_cond_init(&qemu_pause_cond
);
632 qemu_cond_init(&qemu_work_cond
);
633 qemu_cond_init(&qemu_io_proceeded_cond
);
634 qemu_mutex_init(&qemu_global_mutex
);
636 qemu_thread_get_self(&io_thread
);
639 void run_on_cpu(CPUArchState
*env
, void (*func
)(void *data
), void *data
)
641 CPUState
*cpu
= ENV_GET_CPU(env
);
642 struct qemu_work_item wi
;
644 if (qemu_cpu_is_self(cpu
)) {
651 if (!env
->queued_work_first
) {
652 env
->queued_work_first
= &wi
;
654 env
->queued_work_last
->next
= &wi
;
656 env
->queued_work_last
= &wi
;
662 CPUArchState
*self_env
= cpu_single_env
;
664 qemu_cond_wait(&qemu_work_cond
, &qemu_global_mutex
);
665 cpu_single_env
= self_env
;
669 static void flush_queued_work(CPUArchState
*env
)
671 struct qemu_work_item
*wi
;
673 if (!env
->queued_work_first
) {
677 while ((wi
= env
->queued_work_first
)) {
678 env
->queued_work_first
= wi
->next
;
682 env
->queued_work_last
= NULL
;
683 qemu_cond_broadcast(&qemu_work_cond
);
686 static void qemu_wait_io_event_common(CPUArchState
*env
)
688 CPUState
*cpu
= ENV_GET_CPU(env
);
693 qemu_cond_signal(&qemu_pause_cond
);
695 flush_queued_work(env
);
696 cpu
->thread_kicked
= false;
699 static void qemu_tcg_wait_io_event(void)
703 while (all_cpu_threads_idle()) {
704 /* Start accounting real time to the virtual clock if the CPUs
706 qemu_clock_warp(vm_clock
);
707 qemu_cond_wait(tcg_halt_cond
, &qemu_global_mutex
);
710 while (iothread_requesting_mutex
) {
711 qemu_cond_wait(&qemu_io_proceeded_cond
, &qemu_global_mutex
);
714 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
715 qemu_wait_io_event_common(env
);
719 static void qemu_kvm_wait_io_event(CPUArchState
*env
)
721 while (cpu_thread_is_idle(env
)) {
722 qemu_cond_wait(env
->halt_cond
, &qemu_global_mutex
);
725 qemu_kvm_eat_signals(env
);
726 qemu_wait_io_event_common(env
);
729 static void *qemu_kvm_cpu_thread_fn(void *arg
)
731 CPUArchState
*env
= arg
;
732 CPUState
*cpu
= ENV_GET_CPU(env
);
735 qemu_mutex_lock(&qemu_global_mutex
);
736 qemu_thread_get_self(cpu
->thread
);
737 env
->thread_id
= qemu_get_thread_id();
738 cpu_single_env
= env
;
740 r
= kvm_init_vcpu(env
);
742 fprintf(stderr
, "kvm_init_vcpu failed: %s\n", strerror(-r
));
746 qemu_kvm_init_cpu_signals(env
);
748 /* signal CPU creation */
750 qemu_cond_signal(&qemu_cpu_cond
);
753 if (cpu_can_run(env
)) {
754 r
= kvm_cpu_exec(env
);
755 if (r
== EXCP_DEBUG
) {
756 cpu_handle_guest_debug(env
);
759 qemu_kvm_wait_io_event(env
);
765 static void *qemu_dummy_cpu_thread_fn(void *arg
)
768 fprintf(stderr
, "qtest is not supported under Windows\n");
771 CPUArchState
*env
= arg
;
772 CPUState
*cpu
= ENV_GET_CPU(env
);
776 qemu_mutex_lock_iothread();
777 qemu_thread_get_self(cpu
->thread
);
778 env
->thread_id
= qemu_get_thread_id();
780 sigemptyset(&waitset
);
781 sigaddset(&waitset
, SIG_IPI
);
783 /* signal CPU creation */
785 qemu_cond_signal(&qemu_cpu_cond
);
787 cpu_single_env
= env
;
789 cpu_single_env
= NULL
;
790 qemu_mutex_unlock_iothread();
793 r
= sigwait(&waitset
, &sig
);
794 } while (r
== -1 && (errno
== EAGAIN
|| errno
== EINTR
));
799 qemu_mutex_lock_iothread();
800 cpu_single_env
= env
;
801 qemu_wait_io_event_common(env
);
808 static void tcg_exec_all(void);
810 static void *qemu_tcg_cpu_thread_fn(void *arg
)
812 CPUArchState
*env
= arg
;
813 CPUState
*cpu
= ENV_GET_CPU(env
);
815 qemu_tcg_init_cpu_signals();
816 qemu_thread_get_self(cpu
->thread
);
818 /* signal CPU creation */
819 qemu_mutex_lock(&qemu_global_mutex
);
820 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
821 cpu
= ENV_GET_CPU(env
);
822 env
->thread_id
= qemu_get_thread_id();
825 qemu_cond_signal(&qemu_cpu_cond
);
827 /* wait for initial kick-off after machine start */
828 while (first_cpu
->stopped
) {
829 qemu_cond_wait(tcg_halt_cond
, &qemu_global_mutex
);
831 /* process any pending work */
832 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
833 qemu_wait_io_event_common(env
);
839 if (use_icount
&& qemu_clock_deadline(vm_clock
) <= 0) {
842 qemu_tcg_wait_io_event();
848 static void qemu_cpu_kick_thread(CPUState
*cpu
)
853 err
= pthread_kill(cpu
->thread
->thread
, SIG_IPI
);
855 fprintf(stderr
, "qemu:%s: %s", __func__
, strerror(err
));
859 if (!qemu_cpu_is_self(cpu
)) {
860 SuspendThread(cpu
->hThread
);
862 ResumeThread(cpu
->hThread
);
867 void qemu_cpu_kick(void *_env
)
869 CPUArchState
*env
= _env
;
870 CPUState
*cpu
= ENV_GET_CPU(env
);
872 qemu_cond_broadcast(env
->halt_cond
);
873 if (!tcg_enabled() && !cpu
->thread_kicked
) {
874 qemu_cpu_kick_thread(cpu
);
875 cpu
->thread_kicked
= true;
879 void qemu_cpu_kick_self(void)
882 assert(cpu_single_env
);
883 CPUState
*cpu_single_cpu
= ENV_GET_CPU(cpu_single_env
);
885 if (!cpu_single_cpu
->thread_kicked
) {
886 qemu_cpu_kick_thread(cpu_single_cpu
);
887 cpu_single_cpu
->thread_kicked
= true;
894 bool qemu_cpu_is_self(CPUState
*cpu
)
896 return qemu_thread_is_self(cpu
->thread
);
899 static bool qemu_in_vcpu_thread(void)
901 return cpu_single_env
&& qemu_cpu_is_self(ENV_GET_CPU(cpu_single_env
));
904 void qemu_mutex_lock_iothread(void)
906 if (!tcg_enabled()) {
907 qemu_mutex_lock(&qemu_global_mutex
);
909 iothread_requesting_mutex
= true;
910 if (qemu_mutex_trylock(&qemu_global_mutex
)) {
911 qemu_cpu_kick_thread(ENV_GET_CPU(first_cpu
));
912 qemu_mutex_lock(&qemu_global_mutex
);
914 iothread_requesting_mutex
= false;
915 qemu_cond_broadcast(&qemu_io_proceeded_cond
);
919 void qemu_mutex_unlock_iothread(void)
921 qemu_mutex_unlock(&qemu_global_mutex
);
924 static int all_vcpus_paused(void)
926 CPUArchState
*penv
= first_cpu
;
929 if (!penv
->stopped
) {
932 penv
= penv
->next_cpu
;
938 void pause_all_vcpus(void)
940 CPUArchState
*penv
= first_cpu
;
942 qemu_clock_enable(vm_clock
, false);
946 penv
= penv
->next_cpu
;
949 if (qemu_in_vcpu_thread()) {
951 if (!kvm_enabled()) {
955 penv
= penv
->next_cpu
;
961 while (!all_vcpus_paused()) {
962 qemu_cond_wait(&qemu_pause_cond
, &qemu_global_mutex
);
966 penv
= penv
->next_cpu
;
971 void resume_all_vcpus(void)
973 CPUArchState
*penv
= first_cpu
;
975 qemu_clock_enable(vm_clock
, true);
980 penv
= penv
->next_cpu
;
984 static void qemu_tcg_init_vcpu(void *_env
)
986 CPUArchState
*env
= _env
;
987 CPUState
*cpu
= ENV_GET_CPU(env
);
989 /* share a single thread for all cpus with TCG */
990 if (!tcg_cpu_thread
) {
991 cpu
->thread
= g_malloc0(sizeof(QemuThread
));
992 env
->halt_cond
= g_malloc0(sizeof(QemuCond
));
993 qemu_cond_init(env
->halt_cond
);
994 tcg_halt_cond
= env
->halt_cond
;
995 qemu_thread_create(cpu
->thread
, qemu_tcg_cpu_thread_fn
, env
,
996 QEMU_THREAD_JOINABLE
);
998 cpu
->hThread
= qemu_thread_get_handle(cpu
->thread
);
1000 while (!cpu
->created
) {
1001 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1003 tcg_cpu_thread
= cpu
->thread
;
1005 cpu
->thread
= tcg_cpu_thread
;
1006 env
->halt_cond
= tcg_halt_cond
;
1010 static void qemu_kvm_start_vcpu(CPUArchState
*env
)
1012 CPUState
*cpu
= ENV_GET_CPU(env
);
1014 cpu
->thread
= g_malloc0(sizeof(QemuThread
));
1015 env
->halt_cond
= g_malloc0(sizeof(QemuCond
));
1016 qemu_cond_init(env
->halt_cond
);
1017 qemu_thread_create(cpu
->thread
, qemu_kvm_cpu_thread_fn
, env
,
1018 QEMU_THREAD_JOINABLE
);
1019 while (!cpu
->created
) {
1020 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1024 static void qemu_dummy_start_vcpu(CPUArchState
*env
)
1026 CPUState
*cpu
= ENV_GET_CPU(env
);
1028 cpu
->thread
= g_malloc0(sizeof(QemuThread
));
1029 env
->halt_cond
= g_malloc0(sizeof(QemuCond
));
1030 qemu_cond_init(env
->halt_cond
);
1031 qemu_thread_create(cpu
->thread
, qemu_dummy_cpu_thread_fn
, env
,
1032 QEMU_THREAD_JOINABLE
);
1033 while (!cpu
->created
) {
1034 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1038 void qemu_init_vcpu(void *_env
)
1040 CPUArchState
*env
= _env
;
1042 env
->nr_cores
= smp_cores
;
1043 env
->nr_threads
= smp_threads
;
1045 if (kvm_enabled()) {
1046 qemu_kvm_start_vcpu(env
);
1047 } else if (tcg_enabled()) {
1048 qemu_tcg_init_vcpu(env
);
1050 qemu_dummy_start_vcpu(env
);
1054 void cpu_stop_current(void)
1056 if (cpu_single_env
) {
1057 cpu_single_env
->stop
= 0;
1058 cpu_single_env
->stopped
= 1;
1059 cpu_exit(cpu_single_env
);
1060 qemu_cond_signal(&qemu_pause_cond
);
1064 void vm_stop(RunState state
)
1066 if (qemu_in_vcpu_thread()) {
1067 qemu_system_vmstop_request(state
);
1069 * FIXME: should not return to device code in case
1070 * vm_stop() has been requested.
1078 /* does a state transition even if the VM is already stopped,
1079 current state is forgotten forever */
1080 void vm_stop_force_state(RunState state
)
1082 if (runstate_is_running()) {
1085 runstate_set(state
);
1089 static int tcg_cpu_exec(CPUArchState
*env
)
1092 #ifdef CONFIG_PROFILER
1096 #ifdef CONFIG_PROFILER
1097 ti
= profile_getclock();
1102 qemu_icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
1103 env
->icount_decr
.u16
.low
= 0;
1104 env
->icount_extra
= 0;
1105 count
= qemu_icount_round(qemu_clock_deadline(vm_clock
));
1106 qemu_icount
+= count
;
1107 decr
= (count
> 0xffff) ? 0xffff : count
;
1109 env
->icount_decr
.u16
.low
= decr
;
1110 env
->icount_extra
= count
;
1112 ret
= cpu_exec(env
);
1113 #ifdef CONFIG_PROFILER
1114 qemu_time
+= profile_getclock() - ti
;
1117 /* Fold pending instructions back into the
1118 instruction counter, and clear the interrupt flag. */
1119 qemu_icount
-= (env
->icount_decr
.u16
.low
1120 + env
->icount_extra
);
1121 env
->icount_decr
.u32
= 0;
1122 env
->icount_extra
= 0;
1127 static void tcg_exec_all(void)
1131 /* Account partial waits to the vm_clock. */
1132 qemu_clock_warp(vm_clock
);
1134 if (next_cpu
== NULL
) {
1135 next_cpu
= first_cpu
;
1137 for (; next_cpu
!= NULL
&& !exit_request
; next_cpu
= next_cpu
->next_cpu
) {
1138 CPUArchState
*env
= next_cpu
;
1140 qemu_clock_enable(vm_clock
,
1141 (env
->singlestep_enabled
& SSTEP_NOTIMER
) == 0);
1143 if (cpu_can_run(env
)) {
1144 r
= tcg_cpu_exec(env
);
1145 if (r
== EXCP_DEBUG
) {
1146 cpu_handle_guest_debug(env
);
1149 } else if (env
->stop
|| env
->stopped
) {
1156 void set_numa_modes(void)
1161 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1162 for (i
= 0; i
< nb_numa_nodes
; i
++) {
1163 if (test_bit(env
->cpu_index
, node_cpumask
[i
])) {
1170 void set_cpu_log(const char *optarg
)
1173 const CPULogItem
*item
;
1175 mask
= cpu_str_to_log_mask(optarg
);
1177 printf("Log items (comma separated):\n");
1178 for (item
= cpu_log_items
; item
->mask
!= 0; item
++) {
1179 printf("%-10s %s\n", item
->name
, item
->help
);
1186 void set_cpu_log_filename(const char *optarg
)
1188 cpu_set_log_filename(optarg
);
1191 void list_cpus(FILE *f
, fprintf_function cpu_fprintf
, const char *optarg
)
1193 /* XXX: implement xxx_cpu_list for targets that still miss it */
1194 #if defined(cpu_list)
1195 cpu_list(f
, cpu_fprintf
);
1199 CpuInfoList
*qmp_query_cpus(Error
**errp
)
1201 CpuInfoList
*head
= NULL
, *cur_item
= NULL
;
1204 for(env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1207 cpu_synchronize_state(env
);
1209 info
= g_malloc0(sizeof(*info
));
1210 info
->value
= g_malloc0(sizeof(*info
->value
));
1211 info
->value
->CPU
= env
->cpu_index
;
1212 info
->value
->current
= (env
== first_cpu
);
1213 info
->value
->halted
= env
->halted
;
1214 info
->value
->thread_id
= env
->thread_id
;
1215 #if defined(TARGET_I386)
1216 info
->value
->has_pc
= true;
1217 info
->value
->pc
= env
->eip
+ env
->segs
[R_CS
].base
;
1218 #elif defined(TARGET_PPC)
1219 info
->value
->has_nip
= true;
1220 info
->value
->nip
= env
->nip
;
1221 #elif defined(TARGET_SPARC)
1222 info
->value
->has_pc
= true;
1223 info
->value
->pc
= env
->pc
;
1224 info
->value
->has_npc
= true;
1225 info
->value
->npc
= env
->npc
;
1226 #elif defined(TARGET_MIPS)
1227 info
->value
->has_PC
= true;
1228 info
->value
->PC
= env
->active_tc
.PC
;
1231 /* XXX: waiting for the qapi to support GSList */
1233 head
= cur_item
= info
;
1235 cur_item
->next
= info
;
1243 void qmp_memsave(int64_t addr
, int64_t size
, const char *filename
,
1244 bool has_cpu
, int64_t cpu_index
, Error
**errp
)
1255 for (env
= first_cpu
; env
; env
= env
->next_cpu
) {
1256 if (cpu_index
== env
->cpu_index
) {
1262 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
, "cpu-index",
1267 f
= fopen(filename
, "wb");
1269 error_set(errp
, QERR_OPEN_FILE_FAILED
, filename
);
1277 cpu_memory_rw_debug(env
, addr
, buf
, l
, 0);
1278 if (fwrite(buf
, 1, l
, f
) != l
) {
1279 error_set(errp
, QERR_IO_ERROR
);
1290 void qmp_pmemsave(int64_t addr
, int64_t size
, const char *filename
,
1297 f
= fopen(filename
, "wb");
1299 error_set(errp
, QERR_OPEN_FILE_FAILED
, filename
);
1307 cpu_physical_memory_rw(addr
, buf
, l
, 0);
1308 if (fwrite(buf
, 1, l
, f
) != l
) {
1309 error_set(errp
, QERR_IO_ERROR
);
1320 void qmp_inject_nmi(Error
**errp
)
1322 #if defined(TARGET_I386)
1325 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1326 if (!env
->apic_state
) {
1327 cpu_interrupt(env
, CPU_INTERRUPT_NMI
);
1329 apic_deliver_nmi(env
->apic_state
);
1333 error_set(errp
, QERR_UNSUPPORTED
);