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"
28 #include "monitor/monitor.h"
29 #include "sysemu/sysemu.h"
30 #include "exec/gdbstub.h"
31 #include "sysemu/dma.h"
32 #include "sysemu/kvm.h"
33 #include "qmp-commands.h"
35 #include "qemu/thread.h"
36 #include "sysemu/cpus.h"
37 #include "sysemu/qtest.h"
38 #include "qemu/main-loop.h"
39 #include "qemu/bitmap.h"
42 #include "qemu/compatfd.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 CPUState
*next_cpu
;
65 static bool cpu_thread_is_idle(CPUState
*cpu
)
67 if (cpu
->stop
|| cpu
->queued_work_first
) {
70 if (cpu
->stopped
|| !runstate_is_running()) {
73 if (!cpu
->halted
|| qemu_cpu_has_work(cpu
) ||
74 kvm_halt_in_kernel()) {
80 static bool all_cpu_threads_idle(void)
84 for (cpu
= first_cpu
; cpu
!= NULL
; cpu
= cpu
->next_cpu
) {
85 if (!cpu_thread_is_idle(cpu
)) {
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 CPUState
*cpu
= current_cpu
;
123 icount
= qemu_icount
;
125 CPUArchState
*env
= cpu
->env_ptr
;
126 if (!can_do_io(env
)) {
127 fprintf(stderr
, "Bad clock read\n");
129 icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
131 return qemu_icount_bias
+ (icount
<< icount_time_shift
);
134 /* return the host CPU cycle counter and handle stop/restart */
135 int64_t cpu_get_ticks(void)
138 return cpu_get_icount();
140 if (!timers_state
.cpu_ticks_enabled
) {
141 return timers_state
.cpu_ticks_offset
;
144 ticks
= cpu_get_real_ticks();
145 if (timers_state
.cpu_ticks_prev
> ticks
) {
146 /* Note: non increasing ticks may happen if the host uses
148 timers_state
.cpu_ticks_offset
+= timers_state
.cpu_ticks_prev
- ticks
;
150 timers_state
.cpu_ticks_prev
= ticks
;
151 return ticks
+ timers_state
.cpu_ticks_offset
;
155 /* return the host CPU monotonic timer and handle stop/restart */
156 int64_t cpu_get_clock(void)
159 if (!timers_state
.cpu_ticks_enabled
) {
160 return timers_state
.cpu_clock_offset
;
163 return ti
+ timers_state
.cpu_clock_offset
;
167 /* enable cpu_get_ticks() */
168 void cpu_enable_ticks(void)
170 if (!timers_state
.cpu_ticks_enabled
) {
171 timers_state
.cpu_ticks_offset
-= cpu_get_real_ticks();
172 timers_state
.cpu_clock_offset
-= get_clock();
173 timers_state
.cpu_ticks_enabled
= 1;
177 /* disable cpu_get_ticks() : the clock is stopped. You must not call
178 cpu_get_ticks() after that. */
179 void cpu_disable_ticks(void)
181 if (timers_state
.cpu_ticks_enabled
) {
182 timers_state
.cpu_ticks_offset
= cpu_get_ticks();
183 timers_state
.cpu_clock_offset
= cpu_get_clock();
184 timers_state
.cpu_ticks_enabled
= 0;
188 /* Correlation between real and virtual time is always going to be
189 fairly approximate, so ignore small variation.
190 When the guest is idle real and virtual time will be aligned in
192 #define ICOUNT_WOBBLE (get_ticks_per_sec() / 10)
194 static void icount_adjust(void)
199 static int64_t last_delta
;
200 /* If the VM is not running, then do nothing. */
201 if (!runstate_is_running()) {
204 cur_time
= cpu_get_clock();
205 cur_icount
= qemu_get_clock_ns(vm_clock
);
206 delta
= cur_icount
- cur_time
;
207 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
209 && last_delta
+ ICOUNT_WOBBLE
< delta
* 2
210 && icount_time_shift
> 0) {
211 /* The guest is getting too far ahead. Slow time down. */
215 && last_delta
- ICOUNT_WOBBLE
> delta
* 2
216 && icount_time_shift
< MAX_ICOUNT_SHIFT
) {
217 /* The guest is getting too far behind. Speed time up. */
221 qemu_icount_bias
= cur_icount
- (qemu_icount
<< icount_time_shift
);
224 static void icount_adjust_rt(void *opaque
)
226 qemu_mod_timer(icount_rt_timer
,
227 qemu_get_clock_ms(rt_clock
) + 1000);
231 static void icount_adjust_vm(void *opaque
)
233 qemu_mod_timer(icount_vm_timer
,
234 qemu_get_clock_ns(vm_clock
) + get_ticks_per_sec() / 10);
238 static int64_t qemu_icount_round(int64_t count
)
240 return (count
+ (1 << icount_time_shift
) - 1) >> icount_time_shift
;
243 static void icount_warp_rt(void *opaque
)
245 if (vm_clock_warp_start
== -1) {
249 if (runstate_is_running()) {
250 int64_t clock
= qemu_get_clock_ns(rt_clock
);
251 int64_t warp_delta
= clock
- vm_clock_warp_start
;
252 if (use_icount
== 1) {
253 qemu_icount_bias
+= warp_delta
;
256 * In adaptive mode, do not let the vm_clock run too
257 * far ahead of real time.
259 int64_t cur_time
= cpu_get_clock();
260 int64_t cur_icount
= qemu_get_clock_ns(vm_clock
);
261 int64_t delta
= cur_time
- cur_icount
;
262 qemu_icount_bias
+= MIN(warp_delta
, delta
);
264 if (qemu_clock_expired(vm_clock
)) {
268 vm_clock_warp_start
= -1;
271 void qtest_clock_warp(int64_t dest
)
273 int64_t clock
= qemu_get_clock_ns(vm_clock
);
274 assert(qtest_enabled());
275 while (clock
< dest
) {
276 int64_t deadline
= qemu_clock_deadline(vm_clock
);
277 int64_t warp
= MIN(dest
- clock
, deadline
);
278 qemu_icount_bias
+= warp
;
279 qemu_run_timers(vm_clock
);
280 clock
= qemu_get_clock_ns(vm_clock
);
285 void qemu_clock_warp(QEMUClock
*clock
)
290 * There are too many global variables to make the "warp" behavior
291 * applicable to other clocks. But a clock argument removes the
292 * need for if statements all over the place.
294 if (clock
!= vm_clock
|| !use_icount
) {
299 * If the CPUs have been sleeping, advance the vm_clock timer now. This
300 * ensures that the deadline for the timer is computed correctly below.
301 * This also makes sure that the insn counter is synchronized before the
302 * CPU starts running, in case the CPU is woken by an event other than
303 * the earliest vm_clock timer.
305 icount_warp_rt(NULL
);
306 if (!all_cpu_threads_idle() || !qemu_clock_has_timers(vm_clock
)) {
307 qemu_del_timer(icount_warp_timer
);
311 if (qtest_enabled()) {
312 /* When testing, qtest commands advance icount. */
316 vm_clock_warp_start
= qemu_get_clock_ns(rt_clock
);
317 deadline
= qemu_clock_deadline(vm_clock
);
320 * Ensure the vm_clock proceeds even when the virtual CPU goes to
321 * sleep. Otherwise, the CPU might be waiting for a future timer
322 * interrupt to wake it up, but the interrupt never comes because
323 * the vCPU isn't running any insns and thus doesn't advance the
326 * An extreme solution for this problem would be to never let VCPUs
327 * sleep in icount mode if there is a pending vm_clock timer; rather
328 * time could just advance to the next vm_clock event. Instead, we
329 * do stop VCPUs and only advance vm_clock after some "real" time,
330 * (related to the time left until the next event) has passed. This
331 * rt_clock timer will do this. This avoids that the warps are too
332 * visible externally---for example, you will not be sending network
333 * packets continuously instead of every 100ms.
335 qemu_mod_timer(icount_warp_timer
, vm_clock_warp_start
+ deadline
);
341 static const VMStateDescription vmstate_timers
= {
344 .minimum_version_id
= 1,
345 .minimum_version_id_old
= 1,
346 .fields
= (VMStateField
[]) {
347 VMSTATE_INT64(cpu_ticks_offset
, TimersState
),
348 VMSTATE_INT64(dummy
, TimersState
),
349 VMSTATE_INT64_V(cpu_clock_offset
, TimersState
, 2),
350 VMSTATE_END_OF_LIST()
354 void configure_icount(const char *option
)
356 vmstate_register(NULL
, 0, &vmstate_timers
, &timers_state
);
361 icount_warp_timer
= qemu_new_timer_ns(rt_clock
, icount_warp_rt
, NULL
);
362 if (strcmp(option
, "auto") != 0) {
363 icount_time_shift
= strtol(option
, NULL
, 0);
370 /* 125MIPS seems a reasonable initial guess at the guest speed.
371 It will be corrected fairly quickly anyway. */
372 icount_time_shift
= 3;
374 /* Have both realtime and virtual time triggers for speed adjustment.
375 The realtime trigger catches emulated time passing too slowly,
376 the virtual time trigger catches emulated time passing too fast.
377 Realtime triggers occur even when idle, so use them less frequently
379 icount_rt_timer
= qemu_new_timer_ms(rt_clock
, icount_adjust_rt
, NULL
);
380 qemu_mod_timer(icount_rt_timer
,
381 qemu_get_clock_ms(rt_clock
) + 1000);
382 icount_vm_timer
= qemu_new_timer_ns(vm_clock
, icount_adjust_vm
, NULL
);
383 qemu_mod_timer(icount_vm_timer
,
384 qemu_get_clock_ns(vm_clock
) + get_ticks_per_sec() / 10);
387 /***********************************************************/
388 void hw_error(const char *fmt
, ...)
394 fprintf(stderr
, "qemu: hardware error: ");
395 vfprintf(stderr
, fmt
, ap
);
396 fprintf(stderr
, "\n");
397 for (cpu
= first_cpu
; cpu
!= NULL
; cpu
= cpu
->next_cpu
) {
398 fprintf(stderr
, "CPU #%d:\n", cpu
->cpu_index
);
399 cpu_dump_state(cpu
, stderr
, fprintf
, CPU_DUMP_FPU
);
405 void cpu_synchronize_all_states(void)
409 for (cpu
= first_cpu
; cpu
; cpu
= cpu
->next_cpu
) {
410 cpu_synchronize_state(cpu
);
414 void cpu_synchronize_all_post_reset(void)
418 for (cpu
= first_cpu
; cpu
; cpu
= cpu
->next_cpu
) {
419 cpu_synchronize_post_reset(cpu
);
423 void cpu_synchronize_all_post_init(void)
427 for (cpu
= first_cpu
; cpu
; cpu
= cpu
->next_cpu
) {
428 cpu_synchronize_post_init(cpu
);
432 bool cpu_is_stopped(CPUState
*cpu
)
434 return !runstate_is_running() || cpu
->stopped
;
437 static int do_vm_stop(RunState state
)
441 if (runstate_is_running()) {
445 vm_state_notify(0, state
);
447 ret
= bdrv_flush_all();
448 monitor_protocol_event(QEVENT_STOP
, NULL
);
454 static bool cpu_can_run(CPUState
*cpu
)
459 if (cpu
->stopped
|| !runstate_is_running()) {
465 static void cpu_handle_guest_debug(CPUState
*cpu
)
467 gdb_set_stop_cpu(cpu
);
468 qemu_system_debug_request();
472 static void cpu_signal(int sig
)
475 cpu_exit(current_cpu
);
481 static void sigbus_reraise(void)
484 struct sigaction action
;
486 memset(&action
, 0, sizeof(action
));
487 action
.sa_handler
= SIG_DFL
;
488 if (!sigaction(SIGBUS
, &action
, NULL
)) {
491 sigaddset(&set
, SIGBUS
);
492 sigprocmask(SIG_UNBLOCK
, &set
, NULL
);
494 perror("Failed to re-raise SIGBUS!\n");
498 static void sigbus_handler(int n
, struct qemu_signalfd_siginfo
*siginfo
,
501 if (kvm_on_sigbus(siginfo
->ssi_code
,
502 (void *)(intptr_t)siginfo
->ssi_addr
)) {
507 static void qemu_init_sigbus(void)
509 struct sigaction action
;
511 memset(&action
, 0, sizeof(action
));
512 action
.sa_flags
= SA_SIGINFO
;
513 action
.sa_sigaction
= (void (*)(int, siginfo_t
*, void*))sigbus_handler
;
514 sigaction(SIGBUS
, &action
, NULL
);
516 prctl(PR_MCE_KILL
, PR_MCE_KILL_SET
, PR_MCE_KILL_EARLY
, 0, 0);
519 static void qemu_kvm_eat_signals(CPUState
*cpu
)
521 struct timespec ts
= { 0, 0 };
527 sigemptyset(&waitset
);
528 sigaddset(&waitset
, SIG_IPI
);
529 sigaddset(&waitset
, SIGBUS
);
532 r
= sigtimedwait(&waitset
, &siginfo
, &ts
);
533 if (r
== -1 && !(errno
== EAGAIN
|| errno
== EINTR
)) {
534 perror("sigtimedwait");
540 if (kvm_on_sigbus_vcpu(cpu
, siginfo
.si_code
, siginfo
.si_addr
)) {
548 r
= sigpending(&chkset
);
550 perror("sigpending");
553 } while (sigismember(&chkset
, SIG_IPI
) || sigismember(&chkset
, SIGBUS
));
556 #else /* !CONFIG_LINUX */
558 static void qemu_init_sigbus(void)
562 static void qemu_kvm_eat_signals(CPUState
*cpu
)
565 #endif /* !CONFIG_LINUX */
568 static void dummy_signal(int sig
)
572 static void qemu_kvm_init_cpu_signals(CPUState
*cpu
)
576 struct sigaction sigact
;
578 memset(&sigact
, 0, sizeof(sigact
));
579 sigact
.sa_handler
= dummy_signal
;
580 sigaction(SIG_IPI
, &sigact
, NULL
);
582 pthread_sigmask(SIG_BLOCK
, NULL
, &set
);
583 sigdelset(&set
, SIG_IPI
);
584 sigdelset(&set
, SIGBUS
);
585 r
= kvm_set_signal_mask(cpu
, &set
);
587 fprintf(stderr
, "kvm_set_signal_mask: %s\n", strerror(-r
));
592 static void qemu_tcg_init_cpu_signals(void)
595 struct sigaction sigact
;
597 memset(&sigact
, 0, sizeof(sigact
));
598 sigact
.sa_handler
= cpu_signal
;
599 sigaction(SIG_IPI
, &sigact
, NULL
);
602 sigaddset(&set
, SIG_IPI
);
603 pthread_sigmask(SIG_UNBLOCK
, &set
, NULL
);
607 static void qemu_kvm_init_cpu_signals(CPUState
*cpu
)
612 static void qemu_tcg_init_cpu_signals(void)
617 static QemuMutex qemu_global_mutex
;
618 static QemuCond qemu_io_proceeded_cond
;
619 static bool iothread_requesting_mutex
;
621 static QemuThread io_thread
;
623 static QemuThread
*tcg_cpu_thread
;
624 static QemuCond
*tcg_halt_cond
;
627 static QemuCond qemu_cpu_cond
;
629 static QemuCond qemu_pause_cond
;
630 static QemuCond qemu_work_cond
;
632 void qemu_init_cpu_loop(void)
635 qemu_cond_init(&qemu_cpu_cond
);
636 qemu_cond_init(&qemu_pause_cond
);
637 qemu_cond_init(&qemu_work_cond
);
638 qemu_cond_init(&qemu_io_proceeded_cond
);
639 qemu_mutex_init(&qemu_global_mutex
);
641 qemu_thread_get_self(&io_thread
);
644 void run_on_cpu(CPUState
*cpu
, void (*func
)(void *data
), void *data
)
646 struct qemu_work_item wi
;
648 if (qemu_cpu_is_self(cpu
)) {
655 if (cpu
->queued_work_first
== NULL
) {
656 cpu
->queued_work_first
= &wi
;
658 cpu
->queued_work_last
->next
= &wi
;
660 cpu
->queued_work_last
= &wi
;
666 CPUState
*self_cpu
= current_cpu
;
668 qemu_cond_wait(&qemu_work_cond
, &qemu_global_mutex
);
669 current_cpu
= self_cpu
;
673 static void flush_queued_work(CPUState
*cpu
)
675 struct qemu_work_item
*wi
;
677 if (cpu
->queued_work_first
== NULL
) {
681 while ((wi
= cpu
->queued_work_first
)) {
682 cpu
->queued_work_first
= wi
->next
;
686 cpu
->queued_work_last
= NULL
;
687 qemu_cond_broadcast(&qemu_work_cond
);
690 static void qemu_wait_io_event_common(CPUState
*cpu
)
695 qemu_cond_signal(&qemu_pause_cond
);
697 flush_queued_work(cpu
);
698 cpu
->thread_kicked
= false;
701 static void qemu_tcg_wait_io_event(void)
705 while (all_cpu_threads_idle()) {
706 /* Start accounting real time to the virtual clock if the CPUs
708 qemu_clock_warp(vm_clock
);
709 qemu_cond_wait(tcg_halt_cond
, &qemu_global_mutex
);
712 while (iothread_requesting_mutex
) {
713 qemu_cond_wait(&qemu_io_proceeded_cond
, &qemu_global_mutex
);
716 for (cpu
= first_cpu
; cpu
!= NULL
; cpu
= cpu
->next_cpu
) {
717 qemu_wait_io_event_common(cpu
);
721 static void qemu_kvm_wait_io_event(CPUState
*cpu
)
723 while (cpu_thread_is_idle(cpu
)) {
724 qemu_cond_wait(cpu
->halt_cond
, &qemu_global_mutex
);
727 qemu_kvm_eat_signals(cpu
);
728 qemu_wait_io_event_common(cpu
);
731 static void *qemu_kvm_cpu_thread_fn(void *arg
)
736 qemu_mutex_lock(&qemu_global_mutex
);
737 qemu_thread_get_self(cpu
->thread
);
738 cpu
->thread_id
= qemu_get_thread_id();
741 r
= kvm_init_vcpu(cpu
);
743 fprintf(stderr
, "kvm_init_vcpu failed: %s\n", strerror(-r
));
747 qemu_kvm_init_cpu_signals(cpu
);
749 /* signal CPU creation */
751 qemu_cond_signal(&qemu_cpu_cond
);
754 if (cpu_can_run(cpu
)) {
755 r
= kvm_cpu_exec(cpu
);
756 if (r
== EXCP_DEBUG
) {
757 cpu_handle_guest_debug(cpu
);
760 qemu_kvm_wait_io_event(cpu
);
766 static void *qemu_dummy_cpu_thread_fn(void *arg
)
769 fprintf(stderr
, "qtest is not supported under Windows\n");
776 qemu_mutex_lock_iothread();
777 qemu_thread_get_self(cpu
->thread
);
778 cpu
->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
);
790 qemu_mutex_unlock_iothread();
793 r
= sigwait(&waitset
, &sig
);
794 } while (r
== -1 && (errno
== EAGAIN
|| errno
== EINTR
));
799 qemu_mutex_lock_iothread();
801 qemu_wait_io_event_common(cpu
);
808 static void tcg_exec_all(void);
810 static void tcg_signal_cpu_creation(CPUState
*cpu
, void *data
)
812 cpu
->thread_id
= qemu_get_thread_id();
816 static void *qemu_tcg_cpu_thread_fn(void *arg
)
820 qemu_tcg_init_cpu_signals();
821 qemu_thread_get_self(cpu
->thread
);
823 qemu_mutex_lock(&qemu_global_mutex
);
824 qemu_for_each_cpu(tcg_signal_cpu_creation
, NULL
);
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 (cpu
= first_cpu
; cpu
!= NULL
; cpu
= cpu
->next_cpu
) {
833 qemu_wait_io_event_common(cpu
);
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
)) {
862 if (SuspendThread(cpu
->hThread
) == (DWORD
)-1) {
863 fprintf(stderr
, "qemu:%s: GetLastError:%lu\n", __func__
,
868 /* On multi-core systems, we are not sure that the thread is actually
869 * suspended until we can get the context.
871 tcgContext
.ContextFlags
= CONTEXT_CONTROL
;
872 while (GetThreadContext(cpu
->hThread
, &tcgContext
) != 0) {
878 if (ResumeThread(cpu
->hThread
) == (DWORD
)-1) {
879 fprintf(stderr
, "qemu:%s: GetLastError:%lu\n", __func__
,
887 void qemu_cpu_kick(CPUState
*cpu
)
889 qemu_cond_broadcast(cpu
->halt_cond
);
890 if (!tcg_enabled() && !cpu
->thread_kicked
) {
891 qemu_cpu_kick_thread(cpu
);
892 cpu
->thread_kicked
= true;
896 void qemu_cpu_kick_self(void)
901 if (!current_cpu
->thread_kicked
) {
902 qemu_cpu_kick_thread(current_cpu
);
903 current_cpu
->thread_kicked
= true;
910 bool qemu_cpu_is_self(CPUState
*cpu
)
912 return qemu_thread_is_self(cpu
->thread
);
915 static bool qemu_in_vcpu_thread(void)
917 return current_cpu
&& qemu_cpu_is_self(current_cpu
);
920 void qemu_mutex_lock_iothread(void)
922 if (!tcg_enabled()) {
923 qemu_mutex_lock(&qemu_global_mutex
);
925 iothread_requesting_mutex
= true;
926 if (qemu_mutex_trylock(&qemu_global_mutex
)) {
927 qemu_cpu_kick_thread(first_cpu
);
928 qemu_mutex_lock(&qemu_global_mutex
);
930 iothread_requesting_mutex
= false;
931 qemu_cond_broadcast(&qemu_io_proceeded_cond
);
935 void qemu_mutex_unlock_iothread(void)
937 qemu_mutex_unlock(&qemu_global_mutex
);
940 static int all_vcpus_paused(void)
942 CPUState
*cpu
= first_cpu
;
954 void pause_all_vcpus(void)
956 CPUState
*cpu
= first_cpu
;
958 qemu_clock_enable(vm_clock
, false);
965 if (qemu_in_vcpu_thread()) {
967 if (!kvm_enabled()) {
978 while (!all_vcpus_paused()) {
979 qemu_cond_wait(&qemu_pause_cond
, &qemu_global_mutex
);
988 void cpu_resume(CPUState
*cpu
)
991 cpu
->stopped
= false;
995 void resume_all_vcpus(void)
997 CPUState
*cpu
= first_cpu
;
999 qemu_clock_enable(vm_clock
, true);
1002 cpu
= cpu
->next_cpu
;
1006 static void qemu_tcg_init_vcpu(CPUState
*cpu
)
1008 /* share a single thread for all cpus with TCG */
1009 if (!tcg_cpu_thread
) {
1010 cpu
->thread
= g_malloc0(sizeof(QemuThread
));
1011 cpu
->halt_cond
= g_malloc0(sizeof(QemuCond
));
1012 qemu_cond_init(cpu
->halt_cond
);
1013 tcg_halt_cond
= cpu
->halt_cond
;
1014 qemu_thread_create(cpu
->thread
, qemu_tcg_cpu_thread_fn
, cpu
,
1015 QEMU_THREAD_JOINABLE
);
1017 cpu
->hThread
= qemu_thread_get_handle(cpu
->thread
);
1019 while (!cpu
->created
) {
1020 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1022 tcg_cpu_thread
= cpu
->thread
;
1024 cpu
->thread
= tcg_cpu_thread
;
1025 cpu
->halt_cond
= tcg_halt_cond
;
1029 static void qemu_kvm_start_vcpu(CPUState
*cpu
)
1031 cpu
->thread
= g_malloc0(sizeof(QemuThread
));
1032 cpu
->halt_cond
= g_malloc0(sizeof(QemuCond
));
1033 qemu_cond_init(cpu
->halt_cond
);
1034 qemu_thread_create(cpu
->thread
, qemu_kvm_cpu_thread_fn
, cpu
,
1035 QEMU_THREAD_JOINABLE
);
1036 while (!cpu
->created
) {
1037 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1041 static void qemu_dummy_start_vcpu(CPUState
*cpu
)
1043 cpu
->thread
= g_malloc0(sizeof(QemuThread
));
1044 cpu
->halt_cond
= g_malloc0(sizeof(QemuCond
));
1045 qemu_cond_init(cpu
->halt_cond
);
1046 qemu_thread_create(cpu
->thread
, qemu_dummy_cpu_thread_fn
, cpu
,
1047 QEMU_THREAD_JOINABLE
);
1048 while (!cpu
->created
) {
1049 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1053 void qemu_init_vcpu(CPUState
*cpu
)
1055 cpu
->nr_cores
= smp_cores
;
1056 cpu
->nr_threads
= smp_threads
;
1057 cpu
->stopped
= true;
1058 if (kvm_enabled()) {
1059 qemu_kvm_start_vcpu(cpu
);
1060 } else if (tcg_enabled()) {
1061 qemu_tcg_init_vcpu(cpu
);
1063 qemu_dummy_start_vcpu(cpu
);
1067 void cpu_stop_current(void)
1070 current_cpu
->stop
= false;
1071 current_cpu
->stopped
= true;
1072 cpu_exit(current_cpu
);
1073 qemu_cond_signal(&qemu_pause_cond
);
1077 int vm_stop(RunState state
)
1079 if (qemu_in_vcpu_thread()) {
1080 qemu_system_vmstop_request(state
);
1082 * FIXME: should not return to device code in case
1083 * vm_stop() has been requested.
1089 return do_vm_stop(state
);
1092 /* does a state transition even if the VM is already stopped,
1093 current state is forgotten forever */
1094 int vm_stop_force_state(RunState state
)
1096 if (runstate_is_running()) {
1097 return vm_stop(state
);
1099 runstate_set(state
);
1104 static int tcg_cpu_exec(CPUArchState
*env
)
1107 #ifdef CONFIG_PROFILER
1111 #ifdef CONFIG_PROFILER
1112 ti
= profile_getclock();
1117 qemu_icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
1118 env
->icount_decr
.u16
.low
= 0;
1119 env
->icount_extra
= 0;
1120 count
= qemu_icount_round(qemu_clock_deadline(vm_clock
));
1121 qemu_icount
+= count
;
1122 decr
= (count
> 0xffff) ? 0xffff : count
;
1124 env
->icount_decr
.u16
.low
= decr
;
1125 env
->icount_extra
= count
;
1127 ret
= cpu_exec(env
);
1128 #ifdef CONFIG_PROFILER
1129 qemu_time
+= profile_getclock() - ti
;
1132 /* Fold pending instructions back into the
1133 instruction counter, and clear the interrupt flag. */
1134 qemu_icount
-= (env
->icount_decr
.u16
.low
1135 + env
->icount_extra
);
1136 env
->icount_decr
.u32
= 0;
1137 env
->icount_extra
= 0;
1142 static void tcg_exec_all(void)
1146 /* Account partial waits to the vm_clock. */
1147 qemu_clock_warp(vm_clock
);
1149 if (next_cpu
== NULL
) {
1150 next_cpu
= first_cpu
;
1152 for (; next_cpu
!= NULL
&& !exit_request
; next_cpu
= next_cpu
->next_cpu
) {
1153 CPUState
*cpu
= next_cpu
;
1154 CPUArchState
*env
= cpu
->env_ptr
;
1156 qemu_clock_enable(vm_clock
,
1157 (env
->singlestep_enabled
& SSTEP_NOTIMER
) == 0);
1159 if (cpu_can_run(cpu
)) {
1160 r
= tcg_cpu_exec(env
);
1161 if (r
== EXCP_DEBUG
) {
1162 cpu_handle_guest_debug(cpu
);
1165 } else if (cpu
->stop
|| cpu
->stopped
) {
1172 void set_numa_modes(void)
1177 for (cpu
= first_cpu
; cpu
!= NULL
; cpu
= cpu
->next_cpu
) {
1178 for (i
= 0; i
< nb_numa_nodes
; i
++) {
1179 if (test_bit(cpu
->cpu_index
, node_cpumask
[i
])) {
1186 void list_cpus(FILE *f
, fprintf_function cpu_fprintf
, const char *optarg
)
1188 /* XXX: implement xxx_cpu_list for targets that still miss it */
1189 #if defined(cpu_list)
1190 cpu_list(f
, cpu_fprintf
);
1194 CpuInfoList
*qmp_query_cpus(Error
**errp
)
1196 CpuInfoList
*head
= NULL
, *cur_item
= NULL
;
1199 for (cpu
= first_cpu
; cpu
!= NULL
; cpu
= cpu
->next_cpu
) {
1201 #if defined(TARGET_I386)
1202 X86CPU
*x86_cpu
= X86_CPU(cpu
);
1203 CPUX86State
*env
= &x86_cpu
->env
;
1204 #elif defined(TARGET_PPC)
1205 PowerPCCPU
*ppc_cpu
= POWERPC_CPU(cpu
);
1206 CPUPPCState
*env
= &ppc_cpu
->env
;
1207 #elif defined(TARGET_SPARC)
1208 SPARCCPU
*sparc_cpu
= SPARC_CPU(cpu
);
1209 CPUSPARCState
*env
= &sparc_cpu
->env
;
1210 #elif defined(TARGET_MIPS)
1211 MIPSCPU
*mips_cpu
= MIPS_CPU(cpu
);
1212 CPUMIPSState
*env
= &mips_cpu
->env
;
1215 cpu_synchronize_state(cpu
);
1217 info
= g_malloc0(sizeof(*info
));
1218 info
->value
= g_malloc0(sizeof(*info
->value
));
1219 info
->value
->CPU
= cpu
->cpu_index
;
1220 info
->value
->current
= (cpu
== first_cpu
);
1221 info
->value
->halted
= cpu
->halted
;
1222 info
->value
->thread_id
= cpu
->thread_id
;
1223 #if defined(TARGET_I386)
1224 info
->value
->has_pc
= true;
1225 info
->value
->pc
= env
->eip
+ env
->segs
[R_CS
].base
;
1226 #elif defined(TARGET_PPC)
1227 info
->value
->has_nip
= true;
1228 info
->value
->nip
= env
->nip
;
1229 #elif defined(TARGET_SPARC)
1230 info
->value
->has_pc
= true;
1231 info
->value
->pc
= env
->pc
;
1232 info
->value
->has_npc
= true;
1233 info
->value
->npc
= env
->npc
;
1234 #elif defined(TARGET_MIPS)
1235 info
->value
->has_PC
= true;
1236 info
->value
->PC
= env
->active_tc
.PC
;
1239 /* XXX: waiting for the qapi to support GSList */
1241 head
= cur_item
= info
;
1243 cur_item
->next
= info
;
1251 void qmp_memsave(int64_t addr
, int64_t size
, const char *filename
,
1252 bool has_cpu
, int64_t cpu_index
, Error
**errp
)
1264 cpu
= qemu_get_cpu(cpu_index
);
1266 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
, "cpu-index",
1272 f
= fopen(filename
, "wb");
1274 error_setg_file_open(errp
, errno
, filename
);
1282 cpu_memory_rw_debug(env
, addr
, buf
, l
, 0);
1283 if (fwrite(buf
, 1, l
, f
) != l
) {
1284 error_set(errp
, QERR_IO_ERROR
);
1295 void qmp_pmemsave(int64_t addr
, int64_t size
, const char *filename
,
1302 f
= fopen(filename
, "wb");
1304 error_setg_file_open(errp
, errno
, filename
);
1312 cpu_physical_memory_rw(addr
, buf
, l
, 0);
1313 if (fwrite(buf
, 1, l
, f
) != l
) {
1314 error_set(errp
, QERR_IO_ERROR
);
1325 void qmp_inject_nmi(Error
**errp
)
1327 #if defined(TARGET_I386)
1330 for (cs
= first_cpu
; cs
!= NULL
; cs
= cs
->next_cpu
) {
1331 X86CPU
*cpu
= X86_CPU(cs
);
1332 CPUX86State
*env
= &cpu
->env
;
1334 if (!env
->apic_state
) {
1335 cpu_interrupt(cs
, CPU_INTERRUPT_NMI
);
1337 apic_deliver_nmi(env
->apic_state
);
1341 error_set(errp
, QERR_UNSUPPORTED
);