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"
37 #include "main-loop.h"
45 #include <sys/prctl.h>
48 #define PR_MCE_KILL 33
51 #ifndef PR_MCE_KILL_SET
52 #define PR_MCE_KILL_SET 1
55 #ifndef PR_MCE_KILL_EARLY
56 #define PR_MCE_KILL_EARLY 1
59 #endif /* CONFIG_LINUX */
61 static CPUArchState
*next_cpu
;
63 /***********************************************************/
64 /* guest cycle counter */
66 /* Conversion factor from emulated instructions to virtual clock ticks. */
67 static int icount_time_shift
;
68 /* Arbitrarily pick 1MIPS as the minimum allowable speed. */
69 #define MAX_ICOUNT_SHIFT 10
70 /* Compensate for varying guest execution speed. */
71 static int64_t qemu_icount_bias
;
72 static QEMUTimer
*icount_rt_timer
;
73 static QEMUTimer
*icount_vm_timer
;
74 static QEMUTimer
*icount_warp_timer
;
75 static int64_t vm_clock_warp_start
;
76 static int64_t qemu_icount
;
78 typedef struct TimersState
{
79 int64_t cpu_ticks_prev
;
80 int64_t cpu_ticks_offset
;
81 int64_t cpu_clock_offset
;
82 int32_t cpu_ticks_enabled
;
86 TimersState timers_state
;
88 /* Return the virtual CPU time, based on the instruction counter. */
89 int64_t cpu_get_icount(void)
92 CPUArchState
*env
= cpu_single_env
;
96 if (!can_do_io(env
)) {
97 fprintf(stderr
, "Bad clock read\n");
99 icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
101 return qemu_icount_bias
+ (icount
<< icount_time_shift
);
104 /* return the host CPU cycle counter and handle stop/restart */
105 int64_t cpu_get_ticks(void)
108 return cpu_get_icount();
110 if (!timers_state
.cpu_ticks_enabled
) {
111 return timers_state
.cpu_ticks_offset
;
114 ticks
= cpu_get_real_ticks();
115 if (timers_state
.cpu_ticks_prev
> ticks
) {
116 /* Note: non increasing ticks may happen if the host uses
118 timers_state
.cpu_ticks_offset
+= timers_state
.cpu_ticks_prev
- ticks
;
120 timers_state
.cpu_ticks_prev
= ticks
;
121 return ticks
+ timers_state
.cpu_ticks_offset
;
125 /* return the host CPU monotonic timer and handle stop/restart */
126 int64_t cpu_get_clock(void)
129 if (!timers_state
.cpu_ticks_enabled
) {
130 return timers_state
.cpu_clock_offset
;
133 return ti
+ timers_state
.cpu_clock_offset
;
137 /* enable cpu_get_ticks() */
138 void cpu_enable_ticks(void)
140 if (!timers_state
.cpu_ticks_enabled
) {
141 timers_state
.cpu_ticks_offset
-= cpu_get_real_ticks();
142 timers_state
.cpu_clock_offset
-= get_clock();
143 timers_state
.cpu_ticks_enabled
= 1;
147 /* disable cpu_get_ticks() : the clock is stopped. You must not call
148 cpu_get_ticks() after that. */
149 void cpu_disable_ticks(void)
151 if (timers_state
.cpu_ticks_enabled
) {
152 timers_state
.cpu_ticks_offset
= cpu_get_ticks();
153 timers_state
.cpu_clock_offset
= cpu_get_clock();
154 timers_state
.cpu_ticks_enabled
= 0;
158 /* Correlation between real and virtual time is always going to be
159 fairly approximate, so ignore small variation.
160 When the guest is idle real and virtual time will be aligned in
162 #define ICOUNT_WOBBLE (get_ticks_per_sec() / 10)
164 static void icount_adjust(void)
169 static int64_t last_delta
;
170 /* If the VM is not running, then do nothing. */
171 if (!runstate_is_running()) {
174 cur_time
= cpu_get_clock();
175 cur_icount
= qemu_get_clock_ns(vm_clock
);
176 delta
= cur_icount
- cur_time
;
177 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
179 && last_delta
+ ICOUNT_WOBBLE
< delta
* 2
180 && icount_time_shift
> 0) {
181 /* The guest is getting too far ahead. Slow time down. */
185 && last_delta
- ICOUNT_WOBBLE
> delta
* 2
186 && icount_time_shift
< MAX_ICOUNT_SHIFT
) {
187 /* The guest is getting too far behind. Speed time up. */
191 qemu_icount_bias
= cur_icount
- (qemu_icount
<< icount_time_shift
);
194 static void icount_adjust_rt(void *opaque
)
196 qemu_mod_timer(icount_rt_timer
,
197 qemu_get_clock_ms(rt_clock
) + 1000);
201 static void icount_adjust_vm(void *opaque
)
203 qemu_mod_timer(icount_vm_timer
,
204 qemu_get_clock_ns(vm_clock
) + get_ticks_per_sec() / 10);
208 static int64_t qemu_icount_round(int64_t count
)
210 return (count
+ (1 << icount_time_shift
) - 1) >> icount_time_shift
;
213 static void icount_warp_rt(void *opaque
)
215 if (vm_clock_warp_start
== -1) {
219 if (runstate_is_running()) {
220 int64_t clock
= qemu_get_clock_ns(rt_clock
);
221 int64_t warp_delta
= clock
- vm_clock_warp_start
;
222 if (use_icount
== 1) {
223 qemu_icount_bias
+= warp_delta
;
226 * In adaptive mode, do not let the vm_clock run too
227 * far ahead of real time.
229 int64_t cur_time
= cpu_get_clock();
230 int64_t cur_icount
= qemu_get_clock_ns(vm_clock
);
231 int64_t delta
= cur_time
- cur_icount
;
232 qemu_icount_bias
+= MIN(warp_delta
, delta
);
234 if (qemu_clock_expired(vm_clock
)) {
238 vm_clock_warp_start
= -1;
241 void qemu_clock_warp(QEMUClock
*clock
)
246 * There are too many global variables to make the "warp" behavior
247 * applicable to other clocks. But a clock argument removes the
248 * need for if statements all over the place.
250 if (clock
!= vm_clock
|| !use_icount
) {
255 * If the CPUs have been sleeping, advance the vm_clock timer now. This
256 * ensures that the deadline for the timer is computed correctly below.
257 * This also makes sure that the insn counter is synchronized before the
258 * CPU starts running, in case the CPU is woken by an event other than
259 * the earliest vm_clock timer.
261 icount_warp_rt(NULL
);
262 if (!all_cpu_threads_idle() || !qemu_clock_has_timers(vm_clock
)) {
263 qemu_del_timer(icount_warp_timer
);
267 vm_clock_warp_start
= qemu_get_clock_ns(rt_clock
);
268 deadline
= qemu_clock_deadline(vm_clock
);
271 * Ensure the vm_clock proceeds even when the virtual CPU goes to
272 * sleep. Otherwise, the CPU might be waiting for a future timer
273 * interrupt to wake it up, but the interrupt never comes because
274 * the vCPU isn't running any insns and thus doesn't advance the
277 * An extreme solution for this problem would be to never let VCPUs
278 * sleep in icount mode if there is a pending vm_clock timer; rather
279 * time could just advance to the next vm_clock event. Instead, we
280 * do stop VCPUs and only advance vm_clock after some "real" time,
281 * (related to the time left until the next event) has passed. This
282 * rt_clock timer will do this. This avoids that the warps are too
283 * visible externally---for example, you will not be sending network
284 * packets continuously instead of every 100ms.
286 qemu_mod_timer(icount_warp_timer
, vm_clock_warp_start
+ deadline
);
292 static const VMStateDescription vmstate_timers
= {
295 .minimum_version_id
= 1,
296 .minimum_version_id_old
= 1,
297 .fields
= (VMStateField
[]) {
298 VMSTATE_INT64(cpu_ticks_offset
, TimersState
),
299 VMSTATE_INT64(dummy
, TimersState
),
300 VMSTATE_INT64_V(cpu_clock_offset
, TimersState
, 2),
301 VMSTATE_END_OF_LIST()
305 void configure_icount(const char *option
)
307 vmstate_register(NULL
, 0, &vmstate_timers
, &timers_state
);
312 icount_warp_timer
= qemu_new_timer_ns(rt_clock
, icount_warp_rt
, NULL
);
313 if (strcmp(option
, "auto") != 0) {
314 icount_time_shift
= strtol(option
, NULL
, 0);
321 /* 125MIPS seems a reasonable initial guess at the guest speed.
322 It will be corrected fairly quickly anyway. */
323 icount_time_shift
= 3;
325 /* Have both realtime and virtual time triggers for speed adjustment.
326 The realtime trigger catches emulated time passing too slowly,
327 the virtual time trigger catches emulated time passing too fast.
328 Realtime triggers occur even when idle, so use them less frequently
330 icount_rt_timer
= qemu_new_timer_ms(rt_clock
, icount_adjust_rt
, NULL
);
331 qemu_mod_timer(icount_rt_timer
,
332 qemu_get_clock_ms(rt_clock
) + 1000);
333 icount_vm_timer
= qemu_new_timer_ns(vm_clock
, icount_adjust_vm
, NULL
);
334 qemu_mod_timer(icount_vm_timer
,
335 qemu_get_clock_ns(vm_clock
) + get_ticks_per_sec() / 10);
338 /***********************************************************/
339 void hw_error(const char *fmt
, ...)
345 fprintf(stderr
, "qemu: hardware error: ");
346 vfprintf(stderr
, fmt
, ap
);
347 fprintf(stderr
, "\n");
348 for(env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
349 fprintf(stderr
, "CPU #%d:\n", env
->cpu_index
);
351 cpu_dump_state(env
, stderr
, fprintf
, X86_DUMP_FPU
);
353 cpu_dump_state(env
, stderr
, fprintf
, 0);
360 void cpu_synchronize_all_states(void)
364 for (cpu
= first_cpu
; cpu
; cpu
= cpu
->next_cpu
) {
365 cpu_synchronize_state(cpu
);
369 void cpu_synchronize_all_post_reset(void)
373 for (cpu
= first_cpu
; cpu
; cpu
= cpu
->next_cpu
) {
374 cpu_synchronize_post_reset(cpu
);
378 void cpu_synchronize_all_post_init(void)
382 for (cpu
= first_cpu
; cpu
; cpu
= cpu
->next_cpu
) {
383 cpu_synchronize_post_init(cpu
);
387 int cpu_is_stopped(CPUArchState
*env
)
389 return !runstate_is_running() || env
->stopped
;
392 static void do_vm_stop(RunState state
)
394 if (runstate_is_running()) {
398 vm_state_notify(0, state
);
401 monitor_protocol_event(QEVENT_STOP
, NULL
);
405 static int cpu_can_run(CPUArchState
*env
)
410 if (env
->stopped
|| !runstate_is_running()) {
416 static bool cpu_thread_is_idle(CPUArchState
*env
)
418 if (env
->stop
|| env
->queued_work_first
) {
421 if (env
->stopped
|| !runstate_is_running()) {
424 if (!env
->halted
|| qemu_cpu_has_work(env
) ||
425 (kvm_enabled() && kvm_irqchip_in_kernel())) {
431 bool all_cpu_threads_idle(void)
435 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
436 if (!cpu_thread_is_idle(env
)) {
443 static void cpu_handle_guest_debug(CPUArchState
*env
)
445 gdb_set_stop_cpu(env
);
446 qemu_system_debug_request();
450 static void cpu_signal(int sig
)
452 if (cpu_single_env
) {
453 cpu_exit(cpu_single_env
);
459 static void sigbus_reraise(void)
462 struct sigaction action
;
464 memset(&action
, 0, sizeof(action
));
465 action
.sa_handler
= SIG_DFL
;
466 if (!sigaction(SIGBUS
, &action
, NULL
)) {
469 sigaddset(&set
, SIGBUS
);
470 sigprocmask(SIG_UNBLOCK
, &set
, NULL
);
472 perror("Failed to re-raise SIGBUS!\n");
476 static void sigbus_handler(int n
, struct qemu_signalfd_siginfo
*siginfo
,
479 if (kvm_on_sigbus(siginfo
->ssi_code
,
480 (void *)(intptr_t)siginfo
->ssi_addr
)) {
485 static void qemu_init_sigbus(void)
487 struct sigaction action
;
489 memset(&action
, 0, sizeof(action
));
490 action
.sa_flags
= SA_SIGINFO
;
491 action
.sa_sigaction
= (void (*)(int, siginfo_t
*, void*))sigbus_handler
;
492 sigaction(SIGBUS
, &action
, NULL
);
494 prctl(PR_MCE_KILL
, PR_MCE_KILL_SET
, PR_MCE_KILL_EARLY
, 0, 0);
497 static void qemu_kvm_eat_signals(CPUArchState
*env
)
499 struct timespec ts
= { 0, 0 };
505 sigemptyset(&waitset
);
506 sigaddset(&waitset
, SIG_IPI
);
507 sigaddset(&waitset
, SIGBUS
);
510 r
= sigtimedwait(&waitset
, &siginfo
, &ts
);
511 if (r
== -1 && !(errno
== EAGAIN
|| errno
== EINTR
)) {
512 perror("sigtimedwait");
518 if (kvm_on_sigbus_vcpu(env
, siginfo
.si_code
, siginfo
.si_addr
)) {
526 r
= sigpending(&chkset
);
528 perror("sigpending");
531 } while (sigismember(&chkset
, SIG_IPI
) || sigismember(&chkset
, SIGBUS
));
534 #else /* !CONFIG_LINUX */
536 static void qemu_init_sigbus(void)
540 static void qemu_kvm_eat_signals(CPUArchState
*env
)
543 #endif /* !CONFIG_LINUX */
546 static void dummy_signal(int sig
)
550 static void qemu_kvm_init_cpu_signals(CPUArchState
*env
)
554 struct sigaction sigact
;
556 memset(&sigact
, 0, sizeof(sigact
));
557 sigact
.sa_handler
= dummy_signal
;
558 sigaction(SIG_IPI
, &sigact
, NULL
);
560 pthread_sigmask(SIG_BLOCK
, NULL
, &set
);
561 sigdelset(&set
, SIG_IPI
);
562 sigdelset(&set
, SIGBUS
);
563 r
= kvm_set_signal_mask(env
, &set
);
565 fprintf(stderr
, "kvm_set_signal_mask: %s\n", strerror(-r
));
570 static void qemu_tcg_init_cpu_signals(void)
573 struct sigaction sigact
;
575 memset(&sigact
, 0, sizeof(sigact
));
576 sigact
.sa_handler
= cpu_signal
;
577 sigaction(SIG_IPI
, &sigact
, NULL
);
580 sigaddset(&set
, SIG_IPI
);
581 pthread_sigmask(SIG_UNBLOCK
, &set
, NULL
);
585 static void qemu_kvm_init_cpu_signals(CPUArchState
*env
)
590 static void qemu_tcg_init_cpu_signals(void)
595 QemuMutex qemu_global_mutex
;
596 static QemuCond qemu_io_proceeded_cond
;
597 static bool iothread_requesting_mutex
;
599 static QemuThread io_thread
;
601 static QemuThread
*tcg_cpu_thread
;
602 static QemuCond
*tcg_halt_cond
;
605 static QemuCond qemu_cpu_cond
;
607 static QemuCond qemu_pause_cond
;
608 static QemuCond qemu_work_cond
;
610 void qemu_init_cpu_loop(void)
613 qemu_cond_init(&qemu_cpu_cond
);
614 qemu_cond_init(&qemu_pause_cond
);
615 qemu_cond_init(&qemu_work_cond
);
616 qemu_cond_init(&qemu_io_proceeded_cond
);
617 qemu_mutex_init(&qemu_global_mutex
);
619 qemu_thread_get_self(&io_thread
);
622 void run_on_cpu(CPUArchState
*env
, void (*func
)(void *data
), void *data
)
624 struct qemu_work_item wi
;
626 if (qemu_cpu_is_self(env
)) {
633 if (!env
->queued_work_first
) {
634 env
->queued_work_first
= &wi
;
636 env
->queued_work_last
->next
= &wi
;
638 env
->queued_work_last
= &wi
;
644 CPUArchState
*self_env
= cpu_single_env
;
646 qemu_cond_wait(&qemu_work_cond
, &qemu_global_mutex
);
647 cpu_single_env
= self_env
;
651 static void flush_queued_work(CPUArchState
*env
)
653 struct qemu_work_item
*wi
;
655 if (!env
->queued_work_first
) {
659 while ((wi
= env
->queued_work_first
)) {
660 env
->queued_work_first
= wi
->next
;
664 env
->queued_work_last
= NULL
;
665 qemu_cond_broadcast(&qemu_work_cond
);
668 static void qemu_wait_io_event_common(CPUArchState
*env
)
673 qemu_cond_signal(&qemu_pause_cond
);
675 flush_queued_work(env
);
676 env
->thread_kicked
= false;
679 static void qemu_tcg_wait_io_event(void)
683 while (all_cpu_threads_idle()) {
684 /* Start accounting real time to the virtual clock if the CPUs
686 qemu_clock_warp(vm_clock
);
687 qemu_cond_wait(tcg_halt_cond
, &qemu_global_mutex
);
690 while (iothread_requesting_mutex
) {
691 qemu_cond_wait(&qemu_io_proceeded_cond
, &qemu_global_mutex
);
694 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
695 qemu_wait_io_event_common(env
);
699 static void qemu_kvm_wait_io_event(CPUArchState
*env
)
701 while (cpu_thread_is_idle(env
)) {
702 qemu_cond_wait(env
->halt_cond
, &qemu_global_mutex
);
705 qemu_kvm_eat_signals(env
);
706 qemu_wait_io_event_common(env
);
709 static void *qemu_kvm_cpu_thread_fn(void *arg
)
711 CPUArchState
*env
= arg
;
714 qemu_mutex_lock(&qemu_global_mutex
);
715 qemu_thread_get_self(env
->thread
);
716 env
->thread_id
= qemu_get_thread_id();
717 cpu_single_env
= env
;
719 r
= kvm_init_vcpu(env
);
721 fprintf(stderr
, "kvm_init_vcpu failed: %s\n", strerror(-r
));
725 qemu_kvm_init_cpu_signals(env
);
727 /* signal CPU creation */
729 qemu_cond_signal(&qemu_cpu_cond
);
732 if (cpu_can_run(env
)) {
733 r
= kvm_cpu_exec(env
);
734 if (r
== EXCP_DEBUG
) {
735 cpu_handle_guest_debug(env
);
738 qemu_kvm_wait_io_event(env
);
744 static void *qemu_dummy_cpu_thread_fn(void *arg
)
747 fprintf(stderr
, "qtest is not supported under Windows\n");
750 CPUArchState
*env
= arg
;
754 qemu_mutex_lock_iothread();
755 qemu_thread_get_self(env
->thread
);
756 env
->thread_id
= qemu_get_thread_id();
758 sigemptyset(&waitset
);
759 sigaddset(&waitset
, SIG_IPI
);
761 /* signal CPU creation */
763 qemu_cond_signal(&qemu_cpu_cond
);
765 cpu_single_env
= env
;
767 cpu_single_env
= NULL
;
768 qemu_mutex_unlock_iothread();
771 r
= sigwait(&waitset
, &sig
);
772 } while (r
== -1 && (errno
== EAGAIN
|| errno
== EINTR
));
777 qemu_mutex_lock_iothread();
778 cpu_single_env
= env
;
779 qemu_wait_io_event_common(env
);
786 static void tcg_exec_all(void);
788 static void *qemu_tcg_cpu_thread_fn(void *arg
)
790 CPUArchState
*env
= arg
;
792 qemu_tcg_init_cpu_signals();
793 qemu_thread_get_self(env
->thread
);
795 /* signal CPU creation */
796 qemu_mutex_lock(&qemu_global_mutex
);
797 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
798 env
->thread_id
= qemu_get_thread_id();
801 qemu_cond_signal(&qemu_cpu_cond
);
803 /* wait for initial kick-off after machine start */
804 while (first_cpu
->stopped
) {
805 qemu_cond_wait(tcg_halt_cond
, &qemu_global_mutex
);
807 /* process any pending work */
808 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
809 qemu_wait_io_event_common(env
);
815 if (use_icount
&& qemu_clock_deadline(vm_clock
) <= 0) {
818 qemu_tcg_wait_io_event();
824 static void qemu_cpu_kick_thread(CPUArchState
*env
)
829 err
= pthread_kill(env
->thread
->thread
, SIG_IPI
);
831 fprintf(stderr
, "qemu:%s: %s", __func__
, strerror(err
));
835 if (!qemu_cpu_is_self(env
)) {
836 SuspendThread(env
->hThread
);
838 ResumeThread(env
->hThread
);
843 void qemu_cpu_kick(void *_env
)
845 CPUArchState
*env
= _env
;
847 qemu_cond_broadcast(env
->halt_cond
);
848 if (!tcg_enabled() && !env
->thread_kicked
) {
849 qemu_cpu_kick_thread(env
);
850 env
->thread_kicked
= true;
854 void qemu_cpu_kick_self(void)
857 assert(cpu_single_env
);
859 if (!cpu_single_env
->thread_kicked
) {
860 qemu_cpu_kick_thread(cpu_single_env
);
861 cpu_single_env
->thread_kicked
= true;
868 int qemu_cpu_is_self(void *_env
)
870 CPUArchState
*env
= _env
;
872 return qemu_thread_is_self(env
->thread
);
875 void qemu_mutex_lock_iothread(void)
877 if (!tcg_enabled()) {
878 qemu_mutex_lock(&qemu_global_mutex
);
880 iothread_requesting_mutex
= true;
881 if (qemu_mutex_trylock(&qemu_global_mutex
)) {
882 qemu_cpu_kick_thread(first_cpu
);
883 qemu_mutex_lock(&qemu_global_mutex
);
885 iothread_requesting_mutex
= false;
886 qemu_cond_broadcast(&qemu_io_proceeded_cond
);
890 void qemu_mutex_unlock_iothread(void)
892 qemu_mutex_unlock(&qemu_global_mutex
);
895 static int all_vcpus_paused(void)
897 CPUArchState
*penv
= first_cpu
;
900 if (!penv
->stopped
) {
903 penv
= penv
->next_cpu
;
909 void pause_all_vcpus(void)
911 CPUArchState
*penv
= first_cpu
;
913 qemu_clock_enable(vm_clock
, false);
917 penv
= penv
->next_cpu
;
920 if (!qemu_thread_is_self(&io_thread
)) {
922 if (!kvm_enabled()) {
926 penv
= penv
->next_cpu
;
932 while (!all_vcpus_paused()) {
933 qemu_cond_wait(&qemu_pause_cond
, &qemu_global_mutex
);
937 penv
= penv
->next_cpu
;
942 void resume_all_vcpus(void)
944 CPUArchState
*penv
= first_cpu
;
946 qemu_clock_enable(vm_clock
, true);
951 penv
= penv
->next_cpu
;
955 static void qemu_tcg_init_vcpu(void *_env
)
957 CPUArchState
*env
= _env
;
959 /* share a single thread for all cpus with TCG */
960 if (!tcg_cpu_thread
) {
961 env
->thread
= g_malloc0(sizeof(QemuThread
));
962 env
->halt_cond
= g_malloc0(sizeof(QemuCond
));
963 qemu_cond_init(env
->halt_cond
);
964 tcg_halt_cond
= env
->halt_cond
;
965 qemu_thread_create(env
->thread
, qemu_tcg_cpu_thread_fn
, env
,
966 QEMU_THREAD_JOINABLE
);
968 env
->hThread
= qemu_thread_get_handle(env
->thread
);
970 while (env
->created
== 0) {
971 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
973 tcg_cpu_thread
= env
->thread
;
975 env
->thread
= tcg_cpu_thread
;
976 env
->halt_cond
= tcg_halt_cond
;
980 static void qemu_kvm_start_vcpu(CPUArchState
*env
)
982 env
->thread
= g_malloc0(sizeof(QemuThread
));
983 env
->halt_cond
= g_malloc0(sizeof(QemuCond
));
984 qemu_cond_init(env
->halt_cond
);
985 qemu_thread_create(env
->thread
, qemu_kvm_cpu_thread_fn
, env
,
986 QEMU_THREAD_JOINABLE
);
987 while (env
->created
== 0) {
988 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
992 static void qemu_dummy_start_vcpu(CPUArchState
*env
)
994 env
->thread
= g_malloc0(sizeof(QemuThread
));
995 env
->halt_cond
= g_malloc0(sizeof(QemuCond
));
996 qemu_cond_init(env
->halt_cond
);
997 qemu_thread_create(env
->thread
, qemu_dummy_cpu_thread_fn
, env
,
998 QEMU_THREAD_JOINABLE
);
999 while (env
->created
== 0) {
1000 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1004 void qemu_init_vcpu(void *_env
)
1006 CPUArchState
*env
= _env
;
1008 env
->nr_cores
= smp_cores
;
1009 env
->nr_threads
= smp_threads
;
1011 if (kvm_enabled()) {
1012 qemu_kvm_start_vcpu(env
);
1013 } else if (tcg_enabled()) {
1014 qemu_tcg_init_vcpu(env
);
1016 qemu_dummy_start_vcpu(env
);
1020 void cpu_stop_current(void)
1022 if (cpu_single_env
) {
1023 cpu_single_env
->stop
= 0;
1024 cpu_single_env
->stopped
= 1;
1025 cpu_exit(cpu_single_env
);
1026 qemu_cond_signal(&qemu_pause_cond
);
1030 void vm_stop(RunState state
)
1032 if (!qemu_thread_is_self(&io_thread
)) {
1033 qemu_system_vmstop_request(state
);
1035 * FIXME: should not return to device code in case
1036 * vm_stop() has been requested.
1044 /* does a state transition even if the VM is already stopped,
1045 current state is forgotten forever */
1046 void vm_stop_force_state(RunState state
)
1048 if (runstate_is_running()) {
1051 runstate_set(state
);
1055 static int tcg_cpu_exec(CPUArchState
*env
)
1058 #ifdef CONFIG_PROFILER
1062 #ifdef CONFIG_PROFILER
1063 ti
= profile_getclock();
1068 qemu_icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
1069 env
->icount_decr
.u16
.low
= 0;
1070 env
->icount_extra
= 0;
1071 count
= qemu_icount_round(qemu_clock_deadline(vm_clock
));
1072 qemu_icount
+= count
;
1073 decr
= (count
> 0xffff) ? 0xffff : count
;
1075 env
->icount_decr
.u16
.low
= decr
;
1076 env
->icount_extra
= count
;
1078 ret
= cpu_exec(env
);
1079 #ifdef CONFIG_PROFILER
1080 qemu_time
+= profile_getclock() - ti
;
1083 /* Fold pending instructions back into the
1084 instruction counter, and clear the interrupt flag. */
1085 qemu_icount
-= (env
->icount_decr
.u16
.low
1086 + env
->icount_extra
);
1087 env
->icount_decr
.u32
= 0;
1088 env
->icount_extra
= 0;
1093 static void tcg_exec_all(void)
1097 /* Account partial waits to the vm_clock. */
1098 qemu_clock_warp(vm_clock
);
1100 if (next_cpu
== NULL
) {
1101 next_cpu
= first_cpu
;
1103 for (; next_cpu
!= NULL
&& !exit_request
; next_cpu
= next_cpu
->next_cpu
) {
1104 CPUArchState
*env
= next_cpu
;
1106 qemu_clock_enable(vm_clock
,
1107 (env
->singlestep_enabled
& SSTEP_NOTIMER
) == 0);
1109 if (cpu_can_run(env
)) {
1110 r
= tcg_cpu_exec(env
);
1111 if (r
== EXCP_DEBUG
) {
1112 cpu_handle_guest_debug(env
);
1115 } else if (env
->stop
|| env
->stopped
) {
1122 void set_numa_modes(void)
1127 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1128 for (i
= 0; i
< nb_numa_nodes
; i
++) {
1129 if (node_cpumask
[i
] & (1 << env
->cpu_index
)) {
1136 void set_cpu_log(const char *optarg
)
1139 const CPULogItem
*item
;
1141 mask
= cpu_str_to_log_mask(optarg
);
1143 printf("Log items (comma separated):\n");
1144 for (item
= cpu_log_items
; item
->mask
!= 0; item
++) {
1145 printf("%-10s %s\n", item
->name
, item
->help
);
1152 void set_cpu_log_filename(const char *optarg
)
1154 cpu_set_log_filename(optarg
);
1157 void list_cpus(FILE *f
, fprintf_function cpu_fprintf
, const char *optarg
)
1159 /* XXX: implement xxx_cpu_list for targets that still miss it */
1160 #if defined(cpu_list_id)
1161 cpu_list_id(f
, cpu_fprintf
, optarg
);
1162 #elif defined(cpu_list)
1163 cpu_list(f
, cpu_fprintf
); /* deprecated */
1167 CpuInfoList
*qmp_query_cpus(Error
**errp
)
1169 CpuInfoList
*head
= NULL
, *cur_item
= NULL
;
1172 for(env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1175 cpu_synchronize_state(env
);
1177 info
= g_malloc0(sizeof(*info
));
1178 info
->value
= g_malloc0(sizeof(*info
->value
));
1179 info
->value
->CPU
= env
->cpu_index
;
1180 info
->value
->current
= (env
== first_cpu
);
1181 info
->value
->halted
= env
->halted
;
1182 info
->value
->thread_id
= env
->thread_id
;
1183 #if defined(TARGET_I386)
1184 info
->value
->has_pc
= true;
1185 info
->value
->pc
= env
->eip
+ env
->segs
[R_CS
].base
;
1186 #elif defined(TARGET_PPC)
1187 info
->value
->has_nip
= true;
1188 info
->value
->nip
= env
->nip
;
1189 #elif defined(TARGET_SPARC)
1190 info
->value
->has_pc
= true;
1191 info
->value
->pc
= env
->pc
;
1192 info
->value
->has_npc
= true;
1193 info
->value
->npc
= env
->npc
;
1194 #elif defined(TARGET_MIPS)
1195 info
->value
->has_PC
= true;
1196 info
->value
->PC
= env
->active_tc
.PC
;
1199 /* XXX: waiting for the qapi to support GSList */
1201 head
= cur_item
= info
;
1203 cur_item
->next
= info
;
1211 void qmp_memsave(int64_t addr
, int64_t size
, const char *filename
,
1212 bool has_cpu
, int64_t cpu_index
, Error
**errp
)
1223 for (env
= first_cpu
; env
; env
= env
->next_cpu
) {
1224 if (cpu_index
== env
->cpu_index
) {
1230 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
, "cpu-index",
1235 f
= fopen(filename
, "wb");
1237 error_set(errp
, QERR_OPEN_FILE_FAILED
, filename
);
1245 cpu_memory_rw_debug(env
, addr
, buf
, l
, 0);
1246 if (fwrite(buf
, 1, l
, f
) != l
) {
1247 error_set(errp
, QERR_IO_ERROR
);
1258 void qmp_pmemsave(int64_t addr
, int64_t size
, const char *filename
,
1265 f
= fopen(filename
, "wb");
1267 error_set(errp
, QERR_OPEN_FILE_FAILED
, filename
);
1275 cpu_physical_memory_rw(addr
, buf
, l
, 0);
1276 if (fwrite(buf
, 1, l
, f
) != l
) {
1277 error_set(errp
, QERR_IO_ERROR
);
1288 void qmp_inject_nmi(Error
**errp
)
1290 #if defined(TARGET_I386)
1293 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1294 if (!env
->apic_state
) {
1295 cpu_interrupt(env
, CPU_INTERRUPT_NMI
);
1297 apic_deliver_nmi(env
->apic_state
);
1301 error_set(errp
, QERR_UNSUPPORTED
);