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 CPUState
*cpu
= ENV_GET_CPU(env
);
69 if (cpu
->stop
|| env
->queued_work_first
) {
72 if (cpu
->stopped
|| !runstate_is_running()) {
75 if (!env
->halted
|| qemu_cpu_has_work(env
) ||
76 kvm_async_interrupts_enabled()) {
82 static bool all_cpu_threads_idle(void)
86 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
87 if (!cpu_thread_is_idle(env
)) {
94 /***********************************************************/
95 /* guest cycle counter */
97 /* Conversion factor from emulated instructions to virtual clock ticks. */
98 static int icount_time_shift
;
99 /* Arbitrarily pick 1MIPS as the minimum allowable speed. */
100 #define MAX_ICOUNT_SHIFT 10
101 /* Compensate for varying guest execution speed. */
102 static int64_t qemu_icount_bias
;
103 static QEMUTimer
*icount_rt_timer
;
104 static QEMUTimer
*icount_vm_timer
;
105 static QEMUTimer
*icount_warp_timer
;
106 static int64_t vm_clock_warp_start
;
107 static int64_t qemu_icount
;
109 typedef struct TimersState
{
110 int64_t cpu_ticks_prev
;
111 int64_t cpu_ticks_offset
;
112 int64_t cpu_clock_offset
;
113 int32_t cpu_ticks_enabled
;
117 TimersState timers_state
;
119 /* Return the virtual CPU time, based on the instruction counter. */
120 int64_t cpu_get_icount(void)
123 CPUArchState
*env
= cpu_single_env
;
125 icount
= qemu_icount
;
127 if (!can_do_io(env
)) {
128 fprintf(stderr
, "Bad clock read\n");
130 icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
132 return qemu_icount_bias
+ (icount
<< icount_time_shift
);
135 /* return the host CPU cycle counter and handle stop/restart */
136 int64_t cpu_get_ticks(void)
139 return cpu_get_icount();
141 if (!timers_state
.cpu_ticks_enabled
) {
142 return timers_state
.cpu_ticks_offset
;
145 ticks
= cpu_get_real_ticks();
146 if (timers_state
.cpu_ticks_prev
> ticks
) {
147 /* Note: non increasing ticks may happen if the host uses
149 timers_state
.cpu_ticks_offset
+= timers_state
.cpu_ticks_prev
- ticks
;
151 timers_state
.cpu_ticks_prev
= ticks
;
152 return ticks
+ timers_state
.cpu_ticks_offset
;
156 /* return the host CPU monotonic timer and handle stop/restart */
157 int64_t cpu_get_clock(void)
160 if (!timers_state
.cpu_ticks_enabled
) {
161 return timers_state
.cpu_clock_offset
;
164 return ti
+ timers_state
.cpu_clock_offset
;
168 /* enable cpu_get_ticks() */
169 void cpu_enable_ticks(void)
171 if (!timers_state
.cpu_ticks_enabled
) {
172 timers_state
.cpu_ticks_offset
-= cpu_get_real_ticks();
173 timers_state
.cpu_clock_offset
-= get_clock();
174 timers_state
.cpu_ticks_enabled
= 1;
178 /* disable cpu_get_ticks() : the clock is stopped. You must not call
179 cpu_get_ticks() after that. */
180 void cpu_disable_ticks(void)
182 if (timers_state
.cpu_ticks_enabled
) {
183 timers_state
.cpu_ticks_offset
= cpu_get_ticks();
184 timers_state
.cpu_clock_offset
= cpu_get_clock();
185 timers_state
.cpu_ticks_enabled
= 0;
189 /* Correlation between real and virtual time is always going to be
190 fairly approximate, so ignore small variation.
191 When the guest is idle real and virtual time will be aligned in
193 #define ICOUNT_WOBBLE (get_ticks_per_sec() / 10)
195 static void icount_adjust(void)
200 static int64_t last_delta
;
201 /* If the VM is not running, then do nothing. */
202 if (!runstate_is_running()) {
205 cur_time
= cpu_get_clock();
206 cur_icount
= qemu_get_clock_ns(vm_clock
);
207 delta
= cur_icount
- cur_time
;
208 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
210 && last_delta
+ ICOUNT_WOBBLE
< delta
* 2
211 && icount_time_shift
> 0) {
212 /* The guest is getting too far ahead. Slow time down. */
216 && last_delta
- ICOUNT_WOBBLE
> delta
* 2
217 && icount_time_shift
< MAX_ICOUNT_SHIFT
) {
218 /* The guest is getting too far behind. Speed time up. */
222 qemu_icount_bias
= cur_icount
- (qemu_icount
<< icount_time_shift
);
225 static void icount_adjust_rt(void *opaque
)
227 qemu_mod_timer(icount_rt_timer
,
228 qemu_get_clock_ms(rt_clock
) + 1000);
232 static void icount_adjust_vm(void *opaque
)
234 qemu_mod_timer(icount_vm_timer
,
235 qemu_get_clock_ns(vm_clock
) + get_ticks_per_sec() / 10);
239 static int64_t qemu_icount_round(int64_t count
)
241 return (count
+ (1 << icount_time_shift
) - 1) >> icount_time_shift
;
244 static void icount_warp_rt(void *opaque
)
246 if (vm_clock_warp_start
== -1) {
250 if (runstate_is_running()) {
251 int64_t clock
= qemu_get_clock_ns(rt_clock
);
252 int64_t warp_delta
= clock
- vm_clock_warp_start
;
253 if (use_icount
== 1) {
254 qemu_icount_bias
+= warp_delta
;
257 * In adaptive mode, do not let the vm_clock run too
258 * far ahead of real time.
260 int64_t cur_time
= cpu_get_clock();
261 int64_t cur_icount
= qemu_get_clock_ns(vm_clock
);
262 int64_t delta
= cur_time
- cur_icount
;
263 qemu_icount_bias
+= MIN(warp_delta
, delta
);
265 if (qemu_clock_expired(vm_clock
)) {
269 vm_clock_warp_start
= -1;
272 void qtest_clock_warp(int64_t dest
)
274 int64_t clock
= qemu_get_clock_ns(vm_clock
);
275 assert(qtest_enabled());
276 while (clock
< dest
) {
277 int64_t deadline
= qemu_clock_deadline(vm_clock
);
278 int64_t warp
= MIN(dest
- clock
, deadline
);
279 qemu_icount_bias
+= warp
;
280 qemu_run_timers(vm_clock
);
281 clock
= qemu_get_clock_ns(vm_clock
);
286 void qemu_clock_warp(QEMUClock
*clock
)
291 * There are too many global variables to make the "warp" behavior
292 * applicable to other clocks. But a clock argument removes the
293 * need for if statements all over the place.
295 if (clock
!= vm_clock
|| !use_icount
) {
300 * If the CPUs have been sleeping, advance the vm_clock timer now. This
301 * ensures that the deadline for the timer is computed correctly below.
302 * This also makes sure that the insn counter is synchronized before the
303 * CPU starts running, in case the CPU is woken by an event other than
304 * the earliest vm_clock timer.
306 icount_warp_rt(NULL
);
307 if (!all_cpu_threads_idle() || !qemu_clock_has_timers(vm_clock
)) {
308 qemu_del_timer(icount_warp_timer
);
312 if (qtest_enabled()) {
313 /* When testing, qtest commands advance icount. */
317 vm_clock_warp_start
= qemu_get_clock_ns(rt_clock
);
318 deadline
= qemu_clock_deadline(vm_clock
);
321 * Ensure the vm_clock proceeds even when the virtual CPU goes to
322 * sleep. Otherwise, the CPU might be waiting for a future timer
323 * interrupt to wake it up, but the interrupt never comes because
324 * the vCPU isn't running any insns and thus doesn't advance the
327 * An extreme solution for this problem would be to never let VCPUs
328 * sleep in icount mode if there is a pending vm_clock timer; rather
329 * time could just advance to the next vm_clock event. Instead, we
330 * do stop VCPUs and only advance vm_clock after some "real" time,
331 * (related to the time left until the next event) has passed. This
332 * rt_clock timer will do this. This avoids that the warps are too
333 * visible externally---for example, you will not be sending network
334 * packets continuously instead of every 100ms.
336 qemu_mod_timer(icount_warp_timer
, vm_clock_warp_start
+ deadline
);
342 static const VMStateDescription vmstate_timers
= {
345 .minimum_version_id
= 1,
346 .minimum_version_id_old
= 1,
347 .fields
= (VMStateField
[]) {
348 VMSTATE_INT64(cpu_ticks_offset
, TimersState
),
349 VMSTATE_INT64(dummy
, TimersState
),
350 VMSTATE_INT64_V(cpu_clock_offset
, TimersState
, 2),
351 VMSTATE_END_OF_LIST()
355 void configure_icount(const char *option
)
357 vmstate_register(NULL
, 0, &vmstate_timers
, &timers_state
);
362 icount_warp_timer
= qemu_new_timer_ns(rt_clock
, icount_warp_rt
, NULL
);
363 if (strcmp(option
, "auto") != 0) {
364 icount_time_shift
= strtol(option
, NULL
, 0);
371 /* 125MIPS seems a reasonable initial guess at the guest speed.
372 It will be corrected fairly quickly anyway. */
373 icount_time_shift
= 3;
375 /* Have both realtime and virtual time triggers for speed adjustment.
376 The realtime trigger catches emulated time passing too slowly,
377 the virtual time trigger catches emulated time passing too fast.
378 Realtime triggers occur even when idle, so use them less frequently
380 icount_rt_timer
= qemu_new_timer_ms(rt_clock
, icount_adjust_rt
, NULL
);
381 qemu_mod_timer(icount_rt_timer
,
382 qemu_get_clock_ms(rt_clock
) + 1000);
383 icount_vm_timer
= qemu_new_timer_ns(vm_clock
, icount_adjust_vm
, NULL
);
384 qemu_mod_timer(icount_vm_timer
,
385 qemu_get_clock_ns(vm_clock
) + get_ticks_per_sec() / 10);
388 /***********************************************************/
389 void hw_error(const char *fmt
, ...)
395 fprintf(stderr
, "qemu: hardware error: ");
396 vfprintf(stderr
, fmt
, ap
);
397 fprintf(stderr
, "\n");
398 for(env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
399 fprintf(stderr
, "CPU #%d:\n", env
->cpu_index
);
400 cpu_dump_state(env
, stderr
, fprintf
, CPU_DUMP_FPU
);
406 void cpu_synchronize_all_states(void)
410 for (cpu
= first_cpu
; cpu
; cpu
= cpu
->next_cpu
) {
411 cpu_synchronize_state(cpu
);
415 void cpu_synchronize_all_post_reset(void)
419 for (cpu
= first_cpu
; cpu
; cpu
= cpu
->next_cpu
) {
420 cpu_synchronize_post_reset(cpu
);
424 void cpu_synchronize_all_post_init(void)
428 for (cpu
= first_cpu
; cpu
; cpu
= cpu
->next_cpu
) {
429 cpu_synchronize_post_init(cpu
);
433 bool cpu_is_stopped(CPUState
*cpu
)
435 return !runstate_is_running() || cpu
->stopped
;
438 static void do_vm_stop(RunState state
)
440 if (runstate_is_running()) {
444 vm_state_notify(0, state
);
447 monitor_protocol_event(QEVENT_STOP
, NULL
);
451 static bool cpu_can_run(CPUState
*cpu
)
456 if (cpu
->stopped
|| !runstate_is_running()) {
462 static void cpu_handle_guest_debug(CPUArchState
*env
)
464 CPUState
*cpu
= ENV_GET_CPU(env
);
466 gdb_set_stop_cpu(env
);
467 qemu_system_debug_request();
471 static void cpu_signal(int sig
)
473 if (cpu_single_env
) {
474 cpu_exit(cpu_single_env
);
480 static void sigbus_reraise(void)
483 struct sigaction action
;
485 memset(&action
, 0, sizeof(action
));
486 action
.sa_handler
= SIG_DFL
;
487 if (!sigaction(SIGBUS
, &action
, NULL
)) {
490 sigaddset(&set
, SIGBUS
);
491 sigprocmask(SIG_UNBLOCK
, &set
, NULL
);
493 perror("Failed to re-raise SIGBUS!\n");
497 static void sigbus_handler(int n
, struct qemu_signalfd_siginfo
*siginfo
,
500 if (kvm_on_sigbus(siginfo
->ssi_code
,
501 (void *)(intptr_t)siginfo
->ssi_addr
)) {
506 static void qemu_init_sigbus(void)
508 struct sigaction action
;
510 memset(&action
, 0, sizeof(action
));
511 action
.sa_flags
= SA_SIGINFO
;
512 action
.sa_sigaction
= (void (*)(int, siginfo_t
*, void*))sigbus_handler
;
513 sigaction(SIGBUS
, &action
, NULL
);
515 prctl(PR_MCE_KILL
, PR_MCE_KILL_SET
, PR_MCE_KILL_EARLY
, 0, 0);
518 static void qemu_kvm_eat_signals(CPUArchState
*env
)
520 struct timespec ts
= { 0, 0 };
526 sigemptyset(&waitset
);
527 sigaddset(&waitset
, SIG_IPI
);
528 sigaddset(&waitset
, SIGBUS
);
531 r
= sigtimedwait(&waitset
, &siginfo
, &ts
);
532 if (r
== -1 && !(errno
== EAGAIN
|| errno
== EINTR
)) {
533 perror("sigtimedwait");
539 if (kvm_on_sigbus_vcpu(env
, siginfo
.si_code
, siginfo
.si_addr
)) {
547 r
= sigpending(&chkset
);
549 perror("sigpending");
552 } while (sigismember(&chkset
, SIG_IPI
) || sigismember(&chkset
, SIGBUS
));
555 #else /* !CONFIG_LINUX */
557 static void qemu_init_sigbus(void)
561 static void qemu_kvm_eat_signals(CPUArchState
*env
)
564 #endif /* !CONFIG_LINUX */
567 static void dummy_signal(int sig
)
571 static void qemu_kvm_init_cpu_signals(CPUArchState
*env
)
575 struct sigaction sigact
;
577 memset(&sigact
, 0, sizeof(sigact
));
578 sigact
.sa_handler
= dummy_signal
;
579 sigaction(SIG_IPI
, &sigact
, NULL
);
581 pthread_sigmask(SIG_BLOCK
, NULL
, &set
);
582 sigdelset(&set
, SIG_IPI
);
583 sigdelset(&set
, SIGBUS
);
584 r
= kvm_set_signal_mask(env
, &set
);
586 fprintf(stderr
, "kvm_set_signal_mask: %s\n", strerror(-r
));
591 static void qemu_tcg_init_cpu_signals(void)
594 struct sigaction sigact
;
596 memset(&sigact
, 0, sizeof(sigact
));
597 sigact
.sa_handler
= cpu_signal
;
598 sigaction(SIG_IPI
, &sigact
, NULL
);
601 sigaddset(&set
, SIG_IPI
);
602 pthread_sigmask(SIG_UNBLOCK
, &set
, NULL
);
606 static void qemu_kvm_init_cpu_signals(CPUArchState
*env
)
611 static void qemu_tcg_init_cpu_signals(void)
616 static QemuMutex qemu_global_mutex
;
617 static QemuCond qemu_io_proceeded_cond
;
618 static bool iothread_requesting_mutex
;
620 static QemuThread io_thread
;
622 static QemuThread
*tcg_cpu_thread
;
623 static QemuCond
*tcg_halt_cond
;
626 static QemuCond qemu_cpu_cond
;
628 static QemuCond qemu_pause_cond
;
629 static QemuCond qemu_work_cond
;
631 void qemu_init_cpu_loop(void)
634 qemu_cond_init(&qemu_cpu_cond
);
635 qemu_cond_init(&qemu_pause_cond
);
636 qemu_cond_init(&qemu_work_cond
);
637 qemu_cond_init(&qemu_io_proceeded_cond
);
638 qemu_mutex_init(&qemu_global_mutex
);
640 qemu_thread_get_self(&io_thread
);
643 void run_on_cpu(CPUArchState
*env
, void (*func
)(void *data
), void *data
)
645 CPUState
*cpu
= ENV_GET_CPU(env
);
646 struct qemu_work_item wi
;
648 if (qemu_cpu_is_self(cpu
)) {
655 if (!env
->queued_work_first
) {
656 env
->queued_work_first
= &wi
;
658 env
->queued_work_last
->next
= &wi
;
660 env
->queued_work_last
= &wi
;
666 CPUArchState
*self_env
= cpu_single_env
;
668 qemu_cond_wait(&qemu_work_cond
, &qemu_global_mutex
);
669 cpu_single_env
= self_env
;
673 static void flush_queued_work(CPUArchState
*env
)
675 struct qemu_work_item
*wi
;
677 if (!env
->queued_work_first
) {
681 while ((wi
= env
->queued_work_first
)) {
682 env
->queued_work_first
= wi
->next
;
686 env
->queued_work_last
= NULL
;
687 qemu_cond_broadcast(&qemu_work_cond
);
690 static void qemu_wait_io_event_common(CPUArchState
*env
)
692 CPUState
*cpu
= ENV_GET_CPU(env
);
697 qemu_cond_signal(&qemu_pause_cond
);
699 flush_queued_work(env
);
700 cpu
->thread_kicked
= false;
703 static void qemu_tcg_wait_io_event(void)
707 while (all_cpu_threads_idle()) {
708 /* Start accounting real time to the virtual clock if the CPUs
710 qemu_clock_warp(vm_clock
);
711 qemu_cond_wait(tcg_halt_cond
, &qemu_global_mutex
);
714 while (iothread_requesting_mutex
) {
715 qemu_cond_wait(&qemu_io_proceeded_cond
, &qemu_global_mutex
);
718 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
719 qemu_wait_io_event_common(env
);
723 static void qemu_kvm_wait_io_event(CPUArchState
*env
)
725 CPUState
*cpu
= ENV_GET_CPU(env
);
727 while (cpu_thread_is_idle(env
)) {
728 qemu_cond_wait(cpu
->halt_cond
, &qemu_global_mutex
);
731 qemu_kvm_eat_signals(env
);
732 qemu_wait_io_event_common(env
);
735 static void *qemu_kvm_cpu_thread_fn(void *arg
)
737 CPUArchState
*env
= arg
;
738 CPUState
*cpu
= ENV_GET_CPU(env
);
741 qemu_mutex_lock(&qemu_global_mutex
);
742 qemu_thread_get_self(cpu
->thread
);
743 env
->thread_id
= qemu_get_thread_id();
744 cpu_single_env
= env
;
746 r
= kvm_init_vcpu(env
);
748 fprintf(stderr
, "kvm_init_vcpu failed: %s\n", strerror(-r
));
752 qemu_kvm_init_cpu_signals(env
);
754 /* signal CPU creation */
756 qemu_cond_signal(&qemu_cpu_cond
);
759 if (cpu_can_run(cpu
)) {
760 r
= kvm_cpu_exec(env
);
761 if (r
== EXCP_DEBUG
) {
762 cpu_handle_guest_debug(env
);
765 qemu_kvm_wait_io_event(env
);
771 static void *qemu_dummy_cpu_thread_fn(void *arg
)
774 fprintf(stderr
, "qtest is not supported under Windows\n");
777 CPUArchState
*env
= arg
;
778 CPUState
*cpu
= ENV_GET_CPU(env
);
782 qemu_mutex_lock_iothread();
783 qemu_thread_get_self(cpu
->thread
);
784 env
->thread_id
= qemu_get_thread_id();
786 sigemptyset(&waitset
);
787 sigaddset(&waitset
, SIG_IPI
);
789 /* signal CPU creation */
791 qemu_cond_signal(&qemu_cpu_cond
);
793 cpu_single_env
= env
;
795 cpu_single_env
= NULL
;
796 qemu_mutex_unlock_iothread();
799 r
= sigwait(&waitset
, &sig
);
800 } while (r
== -1 && (errno
== EAGAIN
|| errno
== EINTR
));
805 qemu_mutex_lock_iothread();
806 cpu_single_env
= env
;
807 qemu_wait_io_event_common(env
);
814 static void tcg_exec_all(void);
816 static void *qemu_tcg_cpu_thread_fn(void *arg
)
821 qemu_tcg_init_cpu_signals();
822 qemu_thread_get_self(cpu
->thread
);
824 /* signal CPU creation */
825 qemu_mutex_lock(&qemu_global_mutex
);
826 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
827 cpu
= ENV_GET_CPU(env
);
828 env
->thread_id
= qemu_get_thread_id();
831 qemu_cond_signal(&qemu_cpu_cond
);
833 /* wait for initial kick-off after machine start */
834 while (ENV_GET_CPU(first_cpu
)->stopped
) {
835 qemu_cond_wait(tcg_halt_cond
, &qemu_global_mutex
);
837 /* process any pending work */
838 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
839 qemu_wait_io_event_common(env
);
845 if (use_icount
&& qemu_clock_deadline(vm_clock
) <= 0) {
848 qemu_tcg_wait_io_event();
854 static void qemu_cpu_kick_thread(CPUState
*cpu
)
859 err
= pthread_kill(cpu
->thread
->thread
, SIG_IPI
);
861 fprintf(stderr
, "qemu:%s: %s", __func__
, strerror(err
));
865 if (!qemu_cpu_is_self(cpu
)) {
866 SuspendThread(cpu
->hThread
);
868 ResumeThread(cpu
->hThread
);
873 void qemu_cpu_kick(void *_env
)
875 CPUArchState
*env
= _env
;
876 CPUState
*cpu
= ENV_GET_CPU(env
);
878 qemu_cond_broadcast(cpu
->halt_cond
);
879 if (!tcg_enabled() && !cpu
->thread_kicked
) {
880 qemu_cpu_kick_thread(cpu
);
881 cpu
->thread_kicked
= true;
885 void qemu_cpu_kick_self(void)
888 assert(cpu_single_env
);
889 CPUState
*cpu_single_cpu
= ENV_GET_CPU(cpu_single_env
);
891 if (!cpu_single_cpu
->thread_kicked
) {
892 qemu_cpu_kick_thread(cpu_single_cpu
);
893 cpu_single_cpu
->thread_kicked
= true;
900 bool qemu_cpu_is_self(CPUState
*cpu
)
902 return qemu_thread_is_self(cpu
->thread
);
905 static bool qemu_in_vcpu_thread(void)
907 return cpu_single_env
&& qemu_cpu_is_self(ENV_GET_CPU(cpu_single_env
));
910 void qemu_mutex_lock_iothread(void)
912 if (!tcg_enabled()) {
913 qemu_mutex_lock(&qemu_global_mutex
);
915 iothread_requesting_mutex
= true;
916 if (qemu_mutex_trylock(&qemu_global_mutex
)) {
917 qemu_cpu_kick_thread(ENV_GET_CPU(first_cpu
));
918 qemu_mutex_lock(&qemu_global_mutex
);
920 iothread_requesting_mutex
= false;
921 qemu_cond_broadcast(&qemu_io_proceeded_cond
);
925 void qemu_mutex_unlock_iothread(void)
927 qemu_mutex_unlock(&qemu_global_mutex
);
930 static int all_vcpus_paused(void)
932 CPUArchState
*penv
= first_cpu
;
935 CPUState
*pcpu
= ENV_GET_CPU(penv
);
936 if (!pcpu
->stopped
) {
939 penv
= penv
->next_cpu
;
945 void pause_all_vcpus(void)
947 CPUArchState
*penv
= first_cpu
;
949 qemu_clock_enable(vm_clock
, false);
951 CPUState
*pcpu
= ENV_GET_CPU(penv
);
954 penv
= penv
->next_cpu
;
957 if (qemu_in_vcpu_thread()) {
959 if (!kvm_enabled()) {
961 CPUState
*pcpu
= ENV_GET_CPU(penv
);
963 pcpu
->stopped
= true;
964 penv
= penv
->next_cpu
;
970 while (!all_vcpus_paused()) {
971 qemu_cond_wait(&qemu_pause_cond
, &qemu_global_mutex
);
975 penv
= penv
->next_cpu
;
980 void resume_all_vcpus(void)
982 CPUArchState
*penv
= first_cpu
;
984 qemu_clock_enable(vm_clock
, true);
986 CPUState
*pcpu
= ENV_GET_CPU(penv
);
988 pcpu
->stopped
= false;
990 penv
= penv
->next_cpu
;
994 static void qemu_tcg_init_vcpu(void *_env
)
996 CPUArchState
*env
= _env
;
997 CPUState
*cpu
= ENV_GET_CPU(env
);
999 /* share a single thread for all cpus with TCG */
1000 if (!tcg_cpu_thread
) {
1001 cpu
->thread
= g_malloc0(sizeof(QemuThread
));
1002 cpu
->halt_cond
= g_malloc0(sizeof(QemuCond
));
1003 qemu_cond_init(cpu
->halt_cond
);
1004 tcg_halt_cond
= cpu
->halt_cond
;
1005 qemu_thread_create(cpu
->thread
, qemu_tcg_cpu_thread_fn
, cpu
,
1006 QEMU_THREAD_JOINABLE
);
1008 cpu
->hThread
= qemu_thread_get_handle(cpu
->thread
);
1010 while (!cpu
->created
) {
1011 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1013 tcg_cpu_thread
= cpu
->thread
;
1015 cpu
->thread
= tcg_cpu_thread
;
1016 cpu
->halt_cond
= tcg_halt_cond
;
1020 static void qemu_kvm_start_vcpu(CPUArchState
*env
)
1022 CPUState
*cpu
= ENV_GET_CPU(env
);
1024 cpu
->thread
= g_malloc0(sizeof(QemuThread
));
1025 cpu
->halt_cond
= g_malloc0(sizeof(QemuCond
));
1026 qemu_cond_init(cpu
->halt_cond
);
1027 qemu_thread_create(cpu
->thread
, qemu_kvm_cpu_thread_fn
, env
,
1028 QEMU_THREAD_JOINABLE
);
1029 while (!cpu
->created
) {
1030 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1034 static void qemu_dummy_start_vcpu(CPUArchState
*env
)
1036 CPUState
*cpu
= ENV_GET_CPU(env
);
1038 cpu
->thread
= g_malloc0(sizeof(QemuThread
));
1039 cpu
->halt_cond
= g_malloc0(sizeof(QemuCond
));
1040 qemu_cond_init(cpu
->halt_cond
);
1041 qemu_thread_create(cpu
->thread
, qemu_dummy_cpu_thread_fn
, env
,
1042 QEMU_THREAD_JOINABLE
);
1043 while (!cpu
->created
) {
1044 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1048 void qemu_init_vcpu(void *_env
)
1050 CPUArchState
*env
= _env
;
1051 CPUState
*cpu
= ENV_GET_CPU(env
);
1053 env
->nr_cores
= smp_cores
;
1054 env
->nr_threads
= smp_threads
;
1055 cpu
->stopped
= true;
1056 if (kvm_enabled()) {
1057 qemu_kvm_start_vcpu(env
);
1058 } else if (tcg_enabled()) {
1059 qemu_tcg_init_vcpu(env
);
1061 qemu_dummy_start_vcpu(env
);
1065 void cpu_stop_current(void)
1067 if (cpu_single_env
) {
1068 CPUState
*cpu_single_cpu
= ENV_GET_CPU(cpu_single_env
);
1069 cpu_single_cpu
->stop
= false;
1070 cpu_single_cpu
->stopped
= true;
1071 cpu_exit(cpu_single_env
);
1072 qemu_cond_signal(&qemu_pause_cond
);
1076 void vm_stop(RunState state
)
1078 if (qemu_in_vcpu_thread()) {
1079 qemu_system_vmstop_request(state
);
1081 * FIXME: should not return to device code in case
1082 * vm_stop() has been requested.
1090 /* does a state transition even if the VM is already stopped,
1091 current state is forgotten forever */
1092 void vm_stop_force_state(RunState state
)
1094 if (runstate_is_running()) {
1097 runstate_set(state
);
1101 static int tcg_cpu_exec(CPUArchState
*env
)
1104 #ifdef CONFIG_PROFILER
1108 #ifdef CONFIG_PROFILER
1109 ti
= profile_getclock();
1114 qemu_icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
1115 env
->icount_decr
.u16
.low
= 0;
1116 env
->icount_extra
= 0;
1117 count
= qemu_icount_round(qemu_clock_deadline(vm_clock
));
1118 qemu_icount
+= count
;
1119 decr
= (count
> 0xffff) ? 0xffff : count
;
1121 env
->icount_decr
.u16
.low
= decr
;
1122 env
->icount_extra
= count
;
1124 ret
= cpu_exec(env
);
1125 #ifdef CONFIG_PROFILER
1126 qemu_time
+= profile_getclock() - ti
;
1129 /* Fold pending instructions back into the
1130 instruction counter, and clear the interrupt flag. */
1131 qemu_icount
-= (env
->icount_decr
.u16
.low
1132 + env
->icount_extra
);
1133 env
->icount_decr
.u32
= 0;
1134 env
->icount_extra
= 0;
1139 static void tcg_exec_all(void)
1143 /* Account partial waits to the vm_clock. */
1144 qemu_clock_warp(vm_clock
);
1146 if (next_cpu
== NULL
) {
1147 next_cpu
= first_cpu
;
1149 for (; next_cpu
!= NULL
&& !exit_request
; next_cpu
= next_cpu
->next_cpu
) {
1150 CPUArchState
*env
= next_cpu
;
1151 CPUState
*cpu
= ENV_GET_CPU(env
);
1153 qemu_clock_enable(vm_clock
,
1154 (env
->singlestep_enabled
& SSTEP_NOTIMER
) == 0);
1156 if (cpu_can_run(cpu
)) {
1157 r
= tcg_cpu_exec(env
);
1158 if (r
== EXCP_DEBUG
) {
1159 cpu_handle_guest_debug(env
);
1162 } else if (cpu
->stop
|| cpu
->stopped
) {
1169 void set_numa_modes(void)
1174 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1175 for (i
= 0; i
< nb_numa_nodes
; i
++) {
1176 if (test_bit(env
->cpu_index
, node_cpumask
[i
])) {
1183 void set_cpu_log(const char *optarg
)
1186 const CPULogItem
*item
;
1188 mask
= cpu_str_to_log_mask(optarg
);
1190 printf("Log items (comma separated):\n");
1191 for (item
= cpu_log_items
; item
->mask
!= 0; item
++) {
1192 printf("%-10s %s\n", item
->name
, item
->help
);
1199 void set_cpu_log_filename(const char *optarg
)
1201 cpu_set_log_filename(optarg
);
1204 void list_cpus(FILE *f
, fprintf_function cpu_fprintf
, const char *optarg
)
1206 /* XXX: implement xxx_cpu_list for targets that still miss it */
1207 #if defined(cpu_list)
1208 cpu_list(f
, cpu_fprintf
);
1212 CpuInfoList
*qmp_query_cpus(Error
**errp
)
1214 CpuInfoList
*head
= NULL
, *cur_item
= NULL
;
1217 for(env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1220 cpu_synchronize_state(env
);
1222 info
= g_malloc0(sizeof(*info
));
1223 info
->value
= g_malloc0(sizeof(*info
->value
));
1224 info
->value
->CPU
= env
->cpu_index
;
1225 info
->value
->current
= (env
== first_cpu
);
1226 info
->value
->halted
= env
->halted
;
1227 info
->value
->thread_id
= env
->thread_id
;
1228 #if defined(TARGET_I386)
1229 info
->value
->has_pc
= true;
1230 info
->value
->pc
= env
->eip
+ env
->segs
[R_CS
].base
;
1231 #elif defined(TARGET_PPC)
1232 info
->value
->has_nip
= true;
1233 info
->value
->nip
= env
->nip
;
1234 #elif defined(TARGET_SPARC)
1235 info
->value
->has_pc
= true;
1236 info
->value
->pc
= env
->pc
;
1237 info
->value
->has_npc
= true;
1238 info
->value
->npc
= env
->npc
;
1239 #elif defined(TARGET_MIPS)
1240 info
->value
->has_PC
= true;
1241 info
->value
->PC
= env
->active_tc
.PC
;
1244 /* XXX: waiting for the qapi to support GSList */
1246 head
= cur_item
= info
;
1248 cur_item
->next
= info
;
1256 void qmp_memsave(int64_t addr
, int64_t size
, const char *filename
,
1257 bool has_cpu
, int64_t cpu_index
, Error
**errp
)
1268 for (env
= first_cpu
; env
; env
= env
->next_cpu
) {
1269 if (cpu_index
== env
->cpu_index
) {
1275 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
, "cpu-index",
1280 f
= fopen(filename
, "wb");
1282 error_set(errp
, QERR_OPEN_FILE_FAILED
, filename
);
1290 cpu_memory_rw_debug(env
, addr
, buf
, l
, 0);
1291 if (fwrite(buf
, 1, l
, f
) != l
) {
1292 error_set(errp
, QERR_IO_ERROR
);
1303 void qmp_pmemsave(int64_t addr
, int64_t size
, const char *filename
,
1310 f
= fopen(filename
, "wb");
1312 error_set(errp
, QERR_OPEN_FILE_FAILED
, filename
);
1320 cpu_physical_memory_rw(addr
, buf
, l
, 0);
1321 if (fwrite(buf
, 1, l
, f
) != l
) {
1322 error_set(errp
, QERR_IO_ERROR
);
1333 void qmp_inject_nmi(Error
**errp
)
1335 #if defined(TARGET_I386)
1338 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1339 if (!env
->apic_state
) {
1340 cpu_interrupt(env
, CPU_INTERRUPT_NMI
);
1342 apic_deliver_nmi(env
->apic_state
);
1346 error_set(errp
, QERR_UNSUPPORTED
);