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 CPUArchState
*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 (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
85 if (!cpu_thread_is_idle(ENV_GET_CPU(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 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
, ...)
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 cpu
= ENV_GET_CPU(env
);
400 fprintf(stderr
, "CPU #%d:\n", cpu
->cpu_index
);
401 cpu_dump_state(cpu
, stderr
, fprintf
, CPU_DUMP_FPU
);
407 void cpu_synchronize_all_states(void)
411 for (env
= first_cpu
; env
; env
= env
->next_cpu
) {
412 cpu_synchronize_state(ENV_GET_CPU(env
));
416 void cpu_synchronize_all_post_reset(void)
420 for (cpu
= first_cpu
; cpu
; cpu
= cpu
->next_cpu
) {
421 cpu_synchronize_post_reset(ENV_GET_CPU(cpu
));
425 void cpu_synchronize_all_post_init(void)
429 for (cpu
= first_cpu
; cpu
; cpu
= cpu
->next_cpu
) {
430 cpu_synchronize_post_init(ENV_GET_CPU(cpu
));
434 bool cpu_is_stopped(CPUState
*cpu
)
436 return !runstate_is_running() || cpu
->stopped
;
439 static void do_vm_stop(RunState state
)
441 if (runstate_is_running()) {
445 vm_state_notify(0, state
);
448 monitor_protocol_event(QEVENT_STOP
, NULL
);
452 static bool cpu_can_run(CPUState
*cpu
)
457 if (cpu
->stopped
|| !runstate_is_running()) {
463 static void cpu_handle_guest_debug(CPUState
*cpu
)
465 gdb_set_stop_cpu(cpu
);
466 qemu_system_debug_request();
470 static void cpu_signal(int sig
)
473 cpu_exit(current_cpu
);
479 static void sigbus_reraise(void)
482 struct sigaction action
;
484 memset(&action
, 0, sizeof(action
));
485 action
.sa_handler
= SIG_DFL
;
486 if (!sigaction(SIGBUS
, &action
, NULL
)) {
489 sigaddset(&set
, SIGBUS
);
490 sigprocmask(SIG_UNBLOCK
, &set
, NULL
);
492 perror("Failed to re-raise SIGBUS!\n");
496 static void sigbus_handler(int n
, struct qemu_signalfd_siginfo
*siginfo
,
499 if (kvm_on_sigbus(siginfo
->ssi_code
,
500 (void *)(intptr_t)siginfo
->ssi_addr
)) {
505 static void qemu_init_sigbus(void)
507 struct sigaction action
;
509 memset(&action
, 0, sizeof(action
));
510 action
.sa_flags
= SA_SIGINFO
;
511 action
.sa_sigaction
= (void (*)(int, siginfo_t
*, void*))sigbus_handler
;
512 sigaction(SIGBUS
, &action
, NULL
);
514 prctl(PR_MCE_KILL
, PR_MCE_KILL_SET
, PR_MCE_KILL_EARLY
, 0, 0);
517 static void qemu_kvm_eat_signals(CPUState
*cpu
)
519 struct timespec ts
= { 0, 0 };
525 sigemptyset(&waitset
);
526 sigaddset(&waitset
, SIG_IPI
);
527 sigaddset(&waitset
, SIGBUS
);
530 r
= sigtimedwait(&waitset
, &siginfo
, &ts
);
531 if (r
== -1 && !(errno
== EAGAIN
|| errno
== EINTR
)) {
532 perror("sigtimedwait");
538 if (kvm_on_sigbus_vcpu(cpu
, siginfo
.si_code
, siginfo
.si_addr
)) {
546 r
= sigpending(&chkset
);
548 perror("sigpending");
551 } while (sigismember(&chkset
, SIG_IPI
) || sigismember(&chkset
, SIGBUS
));
554 #else /* !CONFIG_LINUX */
556 static void qemu_init_sigbus(void)
560 static void qemu_kvm_eat_signals(CPUState
*cpu
)
563 #endif /* !CONFIG_LINUX */
566 static void dummy_signal(int sig
)
570 static void qemu_kvm_init_cpu_signals(CPUState
*cpu
)
574 struct sigaction sigact
;
576 memset(&sigact
, 0, sizeof(sigact
));
577 sigact
.sa_handler
= dummy_signal
;
578 sigaction(SIG_IPI
, &sigact
, NULL
);
580 pthread_sigmask(SIG_BLOCK
, NULL
, &set
);
581 sigdelset(&set
, SIG_IPI
);
582 sigdelset(&set
, SIGBUS
);
583 r
= kvm_set_signal_mask(cpu
, &set
);
585 fprintf(stderr
, "kvm_set_signal_mask: %s\n", strerror(-r
));
590 static void qemu_tcg_init_cpu_signals(void)
593 struct sigaction sigact
;
595 memset(&sigact
, 0, sizeof(sigact
));
596 sigact
.sa_handler
= cpu_signal
;
597 sigaction(SIG_IPI
, &sigact
, NULL
);
600 sigaddset(&set
, SIG_IPI
);
601 pthread_sigmask(SIG_UNBLOCK
, &set
, NULL
);
605 static void qemu_kvm_init_cpu_signals(CPUState
*cpu
)
610 static void qemu_tcg_init_cpu_signals(void)
615 static QemuMutex qemu_global_mutex
;
616 static QemuCond qemu_io_proceeded_cond
;
617 static bool iothread_requesting_mutex
;
619 static QemuThread io_thread
;
621 static QemuThread
*tcg_cpu_thread
;
622 static QemuCond
*tcg_halt_cond
;
625 static QemuCond qemu_cpu_cond
;
627 static QemuCond qemu_pause_cond
;
628 static QemuCond qemu_work_cond
;
630 void qemu_init_cpu_loop(void)
633 qemu_cond_init(&qemu_cpu_cond
);
634 qemu_cond_init(&qemu_pause_cond
);
635 qemu_cond_init(&qemu_work_cond
);
636 qemu_cond_init(&qemu_io_proceeded_cond
);
637 qemu_mutex_init(&qemu_global_mutex
);
639 qemu_thread_get_self(&io_thread
);
642 void run_on_cpu(CPUState
*cpu
, void (*func
)(void *data
), void *data
)
644 struct qemu_work_item wi
;
646 if (qemu_cpu_is_self(cpu
)) {
653 if (cpu
->queued_work_first
== NULL
) {
654 cpu
->queued_work_first
= &wi
;
656 cpu
->queued_work_last
->next
= &wi
;
658 cpu
->queued_work_last
= &wi
;
664 CPUState
*self_cpu
= current_cpu
;
666 qemu_cond_wait(&qemu_work_cond
, &qemu_global_mutex
);
667 current_cpu
= self_cpu
;
671 static void flush_queued_work(CPUState
*cpu
)
673 struct qemu_work_item
*wi
;
675 if (cpu
->queued_work_first
== NULL
) {
679 while ((wi
= cpu
->queued_work_first
)) {
680 cpu
->queued_work_first
= wi
->next
;
684 cpu
->queued_work_last
= NULL
;
685 qemu_cond_broadcast(&qemu_work_cond
);
688 static void qemu_wait_io_event_common(CPUState
*cpu
)
693 qemu_cond_signal(&qemu_pause_cond
);
695 flush_queued_work(cpu
);
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_GET_CPU(env
));
719 static void qemu_kvm_wait_io_event(CPUState
*cpu
)
721 while (cpu_thread_is_idle(cpu
)) {
722 qemu_cond_wait(cpu
->halt_cond
, &qemu_global_mutex
);
725 qemu_kvm_eat_signals(cpu
);
726 qemu_wait_io_event_common(cpu
);
729 static void *qemu_kvm_cpu_thread_fn(void *arg
)
734 qemu_mutex_lock(&qemu_global_mutex
);
735 qemu_thread_get_self(cpu
->thread
);
736 cpu
->thread_id
= qemu_get_thread_id();
739 r
= kvm_init_vcpu(cpu
);
741 fprintf(stderr
, "kvm_init_vcpu failed: %s\n", strerror(-r
));
745 qemu_kvm_init_cpu_signals(cpu
);
747 /* signal CPU creation */
749 qemu_cond_signal(&qemu_cpu_cond
);
752 if (cpu_can_run(cpu
)) {
753 r
= kvm_cpu_exec(cpu
);
754 if (r
== EXCP_DEBUG
) {
755 cpu_handle_guest_debug(cpu
);
758 qemu_kvm_wait_io_event(cpu
);
764 static void *qemu_dummy_cpu_thread_fn(void *arg
)
767 fprintf(stderr
, "qtest is not supported under Windows\n");
774 qemu_mutex_lock_iothread();
775 qemu_thread_get_self(cpu
->thread
);
776 cpu
->thread_id
= qemu_get_thread_id();
778 sigemptyset(&waitset
);
779 sigaddset(&waitset
, SIG_IPI
);
781 /* signal CPU creation */
783 qemu_cond_signal(&qemu_cpu_cond
);
788 qemu_mutex_unlock_iothread();
791 r
= sigwait(&waitset
, &sig
);
792 } while (r
== -1 && (errno
== EAGAIN
|| errno
== EINTR
));
797 qemu_mutex_lock_iothread();
799 qemu_wait_io_event_common(cpu
);
806 static void tcg_exec_all(void);
808 static void tcg_signal_cpu_creation(CPUState
*cpu
, void *data
)
810 cpu
->thread_id
= qemu_get_thread_id();
814 static void *qemu_tcg_cpu_thread_fn(void *arg
)
819 qemu_tcg_init_cpu_signals();
820 qemu_thread_get_self(cpu
->thread
);
822 qemu_mutex_lock(&qemu_global_mutex
);
823 qemu_for_each_cpu(tcg_signal_cpu_creation
, NULL
);
824 qemu_cond_signal(&qemu_cpu_cond
);
826 /* wait for initial kick-off after machine start */
827 while (ENV_GET_CPU(first_cpu
)->stopped
) {
828 qemu_cond_wait(tcg_halt_cond
, &qemu_global_mutex
);
830 /* process any pending work */
831 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
832 qemu_wait_io_event_common(ENV_GET_CPU(env
));
838 if (use_icount
&& qemu_clock_deadline(vm_clock
) <= 0) {
841 qemu_tcg_wait_io_event();
847 static void qemu_cpu_kick_thread(CPUState
*cpu
)
852 err
= pthread_kill(cpu
->thread
->thread
, SIG_IPI
);
854 fprintf(stderr
, "qemu:%s: %s", __func__
, strerror(err
));
858 if (!qemu_cpu_is_self(cpu
)) {
861 if (SuspendThread(cpu
->hThread
) == (DWORD
)-1) {
862 fprintf(stderr
, "qemu:%s: GetLastError:%lu\n", __func__
,
867 /* On multi-core systems, we are not sure that the thread is actually
868 * suspended until we can get the context.
870 tcgContext
.ContextFlags
= CONTEXT_CONTROL
;
871 while (GetThreadContext(cpu
->hThread
, &tcgContext
) != 0) {
877 if (ResumeThread(cpu
->hThread
) == (DWORD
)-1) {
878 fprintf(stderr
, "qemu:%s: GetLastError:%lu\n", __func__
,
886 void qemu_cpu_kick(CPUState
*cpu
)
888 qemu_cond_broadcast(cpu
->halt_cond
);
889 if (!tcg_enabled() && !cpu
->thread_kicked
) {
890 qemu_cpu_kick_thread(cpu
);
891 cpu
->thread_kicked
= true;
895 void qemu_cpu_kick_self(void)
900 if (!current_cpu
->thread_kicked
) {
901 qemu_cpu_kick_thread(current_cpu
);
902 current_cpu
->thread_kicked
= true;
909 bool qemu_cpu_is_self(CPUState
*cpu
)
911 return qemu_thread_is_self(cpu
->thread
);
914 static bool qemu_in_vcpu_thread(void)
916 return current_cpu
&& qemu_cpu_is_self(current_cpu
);
919 void qemu_mutex_lock_iothread(void)
921 if (!tcg_enabled()) {
922 qemu_mutex_lock(&qemu_global_mutex
);
924 iothread_requesting_mutex
= true;
925 if (qemu_mutex_trylock(&qemu_global_mutex
)) {
926 qemu_cpu_kick_thread(ENV_GET_CPU(first_cpu
));
927 qemu_mutex_lock(&qemu_global_mutex
);
929 iothread_requesting_mutex
= false;
930 qemu_cond_broadcast(&qemu_io_proceeded_cond
);
934 void qemu_mutex_unlock_iothread(void)
936 qemu_mutex_unlock(&qemu_global_mutex
);
939 static int all_vcpus_paused(void)
941 CPUArchState
*penv
= first_cpu
;
944 CPUState
*pcpu
= ENV_GET_CPU(penv
);
945 if (!pcpu
->stopped
) {
948 penv
= penv
->next_cpu
;
954 void pause_all_vcpus(void)
956 CPUArchState
*penv
= first_cpu
;
958 qemu_clock_enable(vm_clock
, false);
960 CPUState
*pcpu
= ENV_GET_CPU(penv
);
963 penv
= penv
->next_cpu
;
966 if (qemu_in_vcpu_thread()) {
968 if (!kvm_enabled()) {
971 CPUState
*pcpu
= ENV_GET_CPU(penv
);
973 pcpu
->stopped
= true;
974 penv
= penv
->next_cpu
;
980 while (!all_vcpus_paused()) {
981 qemu_cond_wait(&qemu_pause_cond
, &qemu_global_mutex
);
984 qemu_cpu_kick(ENV_GET_CPU(penv
));
985 penv
= penv
->next_cpu
;
990 void cpu_resume(CPUState
*cpu
)
993 cpu
->stopped
= false;
997 void resume_all_vcpus(void)
999 CPUArchState
*penv
= first_cpu
;
1001 qemu_clock_enable(vm_clock
, true);
1003 CPUState
*pcpu
= ENV_GET_CPU(penv
);
1005 penv
= penv
->next_cpu
;
1009 static void qemu_tcg_init_vcpu(CPUState
*cpu
)
1011 /* share a single thread for all cpus with TCG */
1012 if (!tcg_cpu_thread
) {
1013 cpu
->thread
= g_malloc0(sizeof(QemuThread
));
1014 cpu
->halt_cond
= g_malloc0(sizeof(QemuCond
));
1015 qemu_cond_init(cpu
->halt_cond
);
1016 tcg_halt_cond
= cpu
->halt_cond
;
1017 qemu_thread_create(cpu
->thread
, qemu_tcg_cpu_thread_fn
, cpu
,
1018 QEMU_THREAD_JOINABLE
);
1020 cpu
->hThread
= qemu_thread_get_handle(cpu
->thread
);
1022 while (!cpu
->created
) {
1023 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1025 tcg_cpu_thread
= cpu
->thread
;
1027 cpu
->thread
= tcg_cpu_thread
;
1028 cpu
->halt_cond
= tcg_halt_cond
;
1032 static void qemu_kvm_start_vcpu(CPUState
*cpu
)
1034 cpu
->thread
= g_malloc0(sizeof(QemuThread
));
1035 cpu
->halt_cond
= g_malloc0(sizeof(QemuCond
));
1036 qemu_cond_init(cpu
->halt_cond
);
1037 qemu_thread_create(cpu
->thread
, qemu_kvm_cpu_thread_fn
, cpu
,
1038 QEMU_THREAD_JOINABLE
);
1039 while (!cpu
->created
) {
1040 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1044 static void qemu_dummy_start_vcpu(CPUState
*cpu
)
1046 cpu
->thread
= g_malloc0(sizeof(QemuThread
));
1047 cpu
->halt_cond
= g_malloc0(sizeof(QemuCond
));
1048 qemu_cond_init(cpu
->halt_cond
);
1049 qemu_thread_create(cpu
->thread
, qemu_dummy_cpu_thread_fn
, cpu
,
1050 QEMU_THREAD_JOINABLE
);
1051 while (!cpu
->created
) {
1052 qemu_cond_wait(&qemu_cpu_cond
, &qemu_global_mutex
);
1056 void qemu_init_vcpu(CPUState
*cpu
)
1058 cpu
->nr_cores
= smp_cores
;
1059 cpu
->nr_threads
= smp_threads
;
1060 cpu
->stopped
= true;
1061 if (kvm_enabled()) {
1062 qemu_kvm_start_vcpu(cpu
);
1063 } else if (tcg_enabled()) {
1064 qemu_tcg_init_vcpu(cpu
);
1066 qemu_dummy_start_vcpu(cpu
);
1070 void cpu_stop_current(void)
1073 current_cpu
->stop
= false;
1074 current_cpu
->stopped
= true;
1075 cpu_exit(current_cpu
);
1076 qemu_cond_signal(&qemu_pause_cond
);
1080 void vm_stop(RunState state
)
1082 if (qemu_in_vcpu_thread()) {
1083 qemu_system_vmstop_request(state
);
1085 * FIXME: should not return to device code in case
1086 * vm_stop() has been requested.
1094 /* does a state transition even if the VM is already stopped,
1095 current state is forgotten forever */
1096 void vm_stop_force_state(RunState state
)
1098 if (runstate_is_running()) {
1101 runstate_set(state
);
1105 static int tcg_cpu_exec(CPUArchState
*env
)
1108 #ifdef CONFIG_PROFILER
1112 #ifdef CONFIG_PROFILER
1113 ti
= profile_getclock();
1118 qemu_icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
1119 env
->icount_decr
.u16
.low
= 0;
1120 env
->icount_extra
= 0;
1121 count
= qemu_icount_round(qemu_clock_deadline(vm_clock
));
1122 qemu_icount
+= count
;
1123 decr
= (count
> 0xffff) ? 0xffff : count
;
1125 env
->icount_decr
.u16
.low
= decr
;
1126 env
->icount_extra
= count
;
1128 ret
= cpu_exec(env
);
1129 #ifdef CONFIG_PROFILER
1130 qemu_time
+= profile_getclock() - ti
;
1133 /* Fold pending instructions back into the
1134 instruction counter, and clear the interrupt flag. */
1135 qemu_icount
-= (env
->icount_decr
.u16
.low
1136 + env
->icount_extra
);
1137 env
->icount_decr
.u32
= 0;
1138 env
->icount_extra
= 0;
1143 static void tcg_exec_all(void)
1147 /* Account partial waits to the vm_clock. */
1148 qemu_clock_warp(vm_clock
);
1150 if (next_cpu
== NULL
) {
1151 next_cpu
= first_cpu
;
1153 for (; next_cpu
!= NULL
&& !exit_request
; next_cpu
= next_cpu
->next_cpu
) {
1154 CPUArchState
*env
= next_cpu
;
1155 CPUState
*cpu
= ENV_GET_CPU(env
);
1157 qemu_clock_enable(vm_clock
,
1158 (env
->singlestep_enabled
& SSTEP_NOTIMER
) == 0);
1160 if (cpu_can_run(cpu
)) {
1161 r
= tcg_cpu_exec(env
);
1162 if (r
== EXCP_DEBUG
) {
1163 cpu_handle_guest_debug(cpu
);
1166 } else if (cpu
->stop
|| cpu
->stopped
) {
1173 void set_numa_modes(void)
1179 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1180 cpu
= ENV_GET_CPU(env
);
1181 for (i
= 0; i
< nb_numa_nodes
; i
++) {
1182 if (test_bit(cpu
->cpu_index
, node_cpumask
[i
])) {
1189 void list_cpus(FILE *f
, fprintf_function cpu_fprintf
, const char *optarg
)
1191 /* XXX: implement xxx_cpu_list for targets that still miss it */
1192 #if defined(cpu_list)
1193 cpu_list(f
, cpu_fprintf
);
1197 CpuInfoList
*qmp_query_cpus(Error
**errp
)
1199 CpuInfoList
*head
= NULL
, *cur_item
= NULL
;
1202 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1203 CPUState
*cpu
= ENV_GET_CPU(env
);
1206 cpu_synchronize_state(cpu
);
1208 info
= g_malloc0(sizeof(*info
));
1209 info
->value
= g_malloc0(sizeof(*info
->value
));
1210 info
->value
->CPU
= cpu
->cpu_index
;
1211 info
->value
->current
= (env
== first_cpu
);
1212 info
->value
->halted
= cpu
->halted
;
1213 info
->value
->thread_id
= cpu
->thread_id
;
1214 #if defined(TARGET_I386)
1215 info
->value
->has_pc
= true;
1216 info
->value
->pc
= env
->eip
+ env
->segs
[R_CS
].base
;
1217 #elif defined(TARGET_PPC)
1218 info
->value
->has_nip
= true;
1219 info
->value
->nip
= env
->nip
;
1220 #elif defined(TARGET_SPARC)
1221 info
->value
->has_pc
= true;
1222 info
->value
->pc
= env
->pc
;
1223 info
->value
->has_npc
= true;
1224 info
->value
->npc
= env
->npc
;
1225 #elif defined(TARGET_MIPS)
1226 info
->value
->has_PC
= true;
1227 info
->value
->PC
= env
->active_tc
.PC
;
1230 /* XXX: waiting for the qapi to support GSList */
1232 head
= cur_item
= info
;
1234 cur_item
->next
= info
;
1242 void qmp_memsave(int64_t addr
, int64_t size
, const char *filename
,
1243 bool has_cpu
, int64_t cpu_index
, Error
**errp
)
1255 cpu
= qemu_get_cpu(cpu_index
);
1257 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
, "cpu-index",
1263 f
= fopen(filename
, "wb");
1265 error_setg_file_open(errp
, errno
, filename
);
1273 cpu_memory_rw_debug(env
, addr
, buf
, l
, 0);
1274 if (fwrite(buf
, 1, l
, f
) != l
) {
1275 error_set(errp
, QERR_IO_ERROR
);
1286 void qmp_pmemsave(int64_t addr
, int64_t size
, const char *filename
,
1293 f
= fopen(filename
, "wb");
1295 error_setg_file_open(errp
, errno
, filename
);
1303 cpu_physical_memory_rw(addr
, buf
, l
, 0);
1304 if (fwrite(buf
, 1, l
, f
) != l
) {
1305 error_set(errp
, QERR_IO_ERROR
);
1316 void qmp_inject_nmi(Error
**errp
)
1318 #if defined(TARGET_I386)
1321 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1322 if (!env
->apic_state
) {
1323 cpu_interrupt(CPU(x86_env_get_cpu(env
)), CPU_INTERRUPT_NMI
);
1325 apic_deliver_nmi(env
->apic_state
);
1329 error_set(errp
, QERR_UNSUPPORTED
);