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 #include "qemu/osdep.h"
26 #include "monitor/monitor.h"
27 #include "qemu/coroutine-tls.h"
28 #include "qapi/error.h"
29 #include "qapi/qapi-commands-machine.h"
30 #include "qapi/qapi-commands-misc.h"
31 #include "qapi/qapi-events-run-state.h"
32 #include "qapi/qmp/qerror.h"
33 #include "exec/gdbstub.h"
34 #include "sysemu/hw_accel.h"
35 #include "exec/cpu-common.h"
36 #include "qemu/thread.h"
37 #include "qemu/main-loop.h"
38 #include "qemu/plugin.h"
39 #include "sysemu/cpus.h"
40 #include "qemu/guest-random.h"
42 #include "sysemu/replay.h"
43 #include "sysemu/runstate.h"
44 #include "sysemu/cpu-timers.h"
45 #include "sysemu/whpx.h"
46 #include "hw/boards.h"
52 #include <sys/prctl.h>
55 #define PR_MCE_KILL 33
58 #ifndef PR_MCE_KILL_SET
59 #define PR_MCE_KILL_SET 1
62 #ifndef PR_MCE_KILL_EARLY
63 #define PR_MCE_KILL_EARLY 1
66 #endif /* CONFIG_LINUX */
68 /* The Big QEMU Lock (BQL) */
72 * The chosen accelerator is supposed to register this.
74 static const AccelOpsClass
*cpus_accel
;
76 bool cpu_is_stopped(CPUState
*cpu
)
78 return cpu
->stopped
|| !runstate_is_running();
81 bool cpu_work_list_empty(CPUState
*cpu
)
83 return QSIMPLEQ_EMPTY_ATOMIC(&cpu
->work_list
);
86 bool cpu_thread_is_idle(CPUState
*cpu
)
88 if (cpu
->stop
|| !cpu_work_list_empty(cpu
)) {
91 if (cpu_is_stopped(cpu
)) {
94 if (!cpu
->halted
|| cpu_has_work(cpu
)) {
97 if (cpus_accel
->cpu_thread_is_idle
) {
98 return cpus_accel
->cpu_thread_is_idle(cpu
);
103 bool all_cpu_threads_idle(void)
108 if (!cpu_thread_is_idle(cpu
)) {
115 /***********************************************************/
116 void hw_error(const char *fmt
, ...)
122 fprintf(stderr
, "qemu: hardware error: ");
123 vfprintf(stderr
, fmt
, ap
);
124 fprintf(stderr
, "\n");
126 fprintf(stderr
, "CPU #%d:\n", cpu
->cpu_index
);
127 cpu_dump_state(cpu
, stderr
, CPU_DUMP_FPU
);
133 void cpu_synchronize_all_states(void)
138 cpu_synchronize_state(cpu
);
142 void cpu_synchronize_all_post_reset(void)
147 cpu_synchronize_post_reset(cpu
);
151 void cpu_synchronize_all_post_init(void)
156 cpu_synchronize_post_init(cpu
);
160 void cpu_synchronize_all_pre_loadvm(void)
165 cpu_synchronize_pre_loadvm(cpu
);
169 void cpu_synchronize_state(CPUState
*cpu
)
171 if (cpus_accel
->synchronize_state
) {
172 cpus_accel
->synchronize_state(cpu
);
176 void cpu_synchronize_post_reset(CPUState
*cpu
)
178 if (cpus_accel
->synchronize_post_reset
) {
179 cpus_accel
->synchronize_post_reset(cpu
);
183 void cpu_synchronize_post_init(CPUState
*cpu
)
185 if (cpus_accel
->synchronize_post_init
) {
186 cpus_accel
->synchronize_post_init(cpu
);
190 void cpu_synchronize_pre_loadvm(CPUState
*cpu
)
192 if (cpus_accel
->synchronize_pre_loadvm
) {
193 cpus_accel
->synchronize_pre_loadvm(cpu
);
197 bool cpus_are_resettable(void)
199 if (cpus_accel
->cpus_are_resettable
) {
200 return cpus_accel
->cpus_are_resettable();
205 void cpu_exec_reset_hold(CPUState
*cpu
)
207 if (cpus_accel
->cpu_reset_hold
) {
208 cpus_accel
->cpu_reset_hold(cpu
);
212 int64_t cpus_get_virtual_clock(void)
217 * need to check that cpus_accel is not NULL, because qcow2 calls
218 * qemu_get_clock_ns(CLOCK_VIRTUAL) without any accel initialized and
219 * with ticks disabled in some io-tests:
220 * 030 040 041 060 099 120 127 140 156 161 172 181 191 192 195 203 229 249 256 267
226 if (cpus_accel
&& cpus_accel
->get_virtual_clock
) {
227 return cpus_accel
->get_virtual_clock();
229 return cpu_get_clock();
233 * Signal the new virtual time to the accelerator. This is only needed
234 * by accelerators that need to track the changes as we warp time.
236 void cpus_set_virtual_clock(int64_t new_time
)
238 if (cpus_accel
&& cpus_accel
->set_virtual_clock
) {
239 cpus_accel
->set_virtual_clock(new_time
);
244 * return the time elapsed in VM between vm_start and vm_stop. Unless
245 * icount is active, cpus_get_elapsed_ticks() uses units of the host CPU cycle
248 int64_t cpus_get_elapsed_ticks(void)
250 if (cpus_accel
->get_elapsed_ticks
) {
251 return cpus_accel
->get_elapsed_ticks();
253 return cpu_get_ticks();
256 static void generic_handle_interrupt(CPUState
*cpu
, int mask
)
258 cpu
->interrupt_request
|= mask
;
260 if (!qemu_cpu_is_self(cpu
)) {
265 void cpu_interrupt(CPUState
*cpu
, int mask
)
267 if (cpus_accel
->handle_interrupt
) {
268 cpus_accel
->handle_interrupt(cpu
, mask
);
270 generic_handle_interrupt(cpu
, mask
);
275 * True if the vm was previously suspended, and has not been woken or reset.
277 static int vm_was_suspended
;
279 void vm_set_suspended(bool suspended
)
281 vm_was_suspended
= suspended
;
284 bool vm_get_suspended(void)
286 return vm_was_suspended
;
289 static int do_vm_stop(RunState state
, bool send_stop
)
292 RunState oldstate
= runstate_get();
294 if (runstate_is_live(oldstate
)) {
295 vm_was_suspended
= (oldstate
== RUN_STATE_SUSPENDED
);
298 if (oldstate
== RUN_STATE_RUNNING
) {
301 vm_state_notify(0, state
);
303 qapi_event_send_stop();
308 ret
= bdrv_flush_all();
309 trace_vm_stop_flush_all(ret
);
314 /* Special vm_stop() variant for terminating the process. Historically clients
315 * did not expect a QMP STOP event and so we need to retain compatibility.
317 int vm_shutdown(void)
319 return do_vm_stop(RUN_STATE_SHUTDOWN
, false);
322 bool cpu_can_run(CPUState
*cpu
)
327 if (cpu_is_stopped(cpu
)) {
333 void cpu_handle_guest_debug(CPUState
*cpu
)
335 if (replay_running_debug()) {
336 if (!cpu
->singlestep_enabled
) {
338 * Report about the breakpoint and
339 * make a single step to skip it
342 cpu_single_step(cpu
, SSTEP_ENABLE
);
344 cpu_single_step(cpu
, 0);
347 gdb_set_stop_cpu(cpu
);
348 qemu_system_debug_request();
354 static void sigbus_reraise(void)
357 struct sigaction action
;
359 memset(&action
, 0, sizeof(action
));
360 action
.sa_handler
= SIG_DFL
;
361 if (!sigaction(SIGBUS
, &action
, NULL
)) {
364 sigaddset(&set
, SIGBUS
);
365 pthread_sigmask(SIG_UNBLOCK
, &set
, NULL
);
367 perror("Failed to re-raise SIGBUS!");
371 static void sigbus_handler(int n
, siginfo_t
*siginfo
, void *ctx
)
373 if (siginfo
->si_code
!= BUS_MCEERR_AO
&& siginfo
->si_code
!= BUS_MCEERR_AR
) {
378 /* Called asynchronously in VCPU thread. */
379 if (kvm_on_sigbus_vcpu(current_cpu
, siginfo
->si_code
, siginfo
->si_addr
)) {
383 /* Called synchronously (via signalfd) in main thread. */
384 if (kvm_on_sigbus(siginfo
->si_code
, siginfo
->si_addr
)) {
390 static void qemu_init_sigbus(void)
392 struct sigaction action
;
395 * ALERT: when modifying this, take care that SIGBUS forwarding in
396 * qemu_prealloc_mem() will continue working as expected.
398 memset(&action
, 0, sizeof(action
));
399 action
.sa_flags
= SA_SIGINFO
;
400 action
.sa_sigaction
= sigbus_handler
;
401 sigaction(SIGBUS
, &action
, NULL
);
403 prctl(PR_MCE_KILL
, PR_MCE_KILL_SET
, PR_MCE_KILL_EARLY
, 0, 0);
405 #else /* !CONFIG_LINUX */
406 static void qemu_init_sigbus(void)
409 #endif /* !CONFIG_LINUX */
411 static QemuThread io_thread
;
414 static QemuCond qemu_cpu_cond
;
416 static QemuCond qemu_pause_cond
;
418 void qemu_init_cpu_loop(void)
421 qemu_cond_init(&qemu_cpu_cond
);
422 qemu_cond_init(&qemu_pause_cond
);
423 qemu_mutex_init(&bql
);
425 qemu_thread_get_self(&io_thread
);
428 void run_on_cpu(CPUState
*cpu
, run_on_cpu_func func
, run_on_cpu_data data
)
430 do_run_on_cpu(cpu
, func
, data
, &bql
);
433 static void qemu_cpu_stop(CPUState
*cpu
, bool exit
)
435 g_assert(qemu_cpu_is_self(cpu
));
441 qemu_cond_broadcast(&qemu_pause_cond
);
444 void qemu_wait_io_event_common(CPUState
*cpu
)
446 qatomic_set_mb(&cpu
->thread_kicked
, false);
448 qemu_cpu_stop(cpu
, false);
450 process_queued_cpu_work(cpu
);
453 void qemu_wait_io_event(CPUState
*cpu
)
457 while (cpu_thread_is_idle(cpu
)) {
460 qemu_plugin_vcpu_idle_cb(cpu
);
462 qemu_cond_wait(cpu
->halt_cond
, &bql
);
465 qemu_plugin_vcpu_resume_cb(cpu
);
468 qemu_wait_io_event_common(cpu
);
471 void cpus_kick_thread(CPUState
*cpu
)
473 if (cpu
->thread_kicked
) {
476 cpu
->thread_kicked
= true;
479 int err
= pthread_kill(cpu
->thread
->thread
, SIG_IPI
);
480 if (err
&& err
!= ESRCH
) {
481 fprintf(stderr
, "qemu:%s: %s", __func__
, strerror(err
));
485 qemu_sem_post(&cpu
->sem
);
489 void qemu_cpu_kick(CPUState
*cpu
)
491 qemu_cond_broadcast(cpu
->halt_cond
);
492 if (cpus_accel
->kick_vcpu_thread
) {
493 cpus_accel
->kick_vcpu_thread(cpu
);
494 } else { /* default */
495 cpus_kick_thread(cpu
);
499 void qemu_cpu_kick_self(void)
502 cpus_kick_thread(current_cpu
);
505 bool qemu_cpu_is_self(CPUState
*cpu
)
507 return qemu_thread_is_self(cpu
->thread
);
510 bool qemu_in_vcpu_thread(void)
512 return current_cpu
&& qemu_cpu_is_self(current_cpu
);
515 QEMU_DEFINE_STATIC_CO_TLS(bool, bql_locked
)
517 bool bql_locked(void)
519 return get_bql_locked();
522 bool qemu_in_main_thread(void)
528 * The BQL is taken from so many places that it is worth profiling the
529 * callers directly, instead of funneling them all through a single function.
531 void bql_lock_impl(const char *file
, int line
)
533 QemuMutexLockFunc bql_lock_fn
= qatomic_read(&bql_mutex_lock_func
);
535 g_assert(!bql_locked());
536 bql_lock_fn(&bql
, file
, line
);
537 set_bql_locked(true);
540 void bql_unlock(void)
542 g_assert(bql_locked());
543 set_bql_locked(false);
544 qemu_mutex_unlock(&bql
);
547 void qemu_cond_wait_bql(QemuCond
*cond
)
549 qemu_cond_wait(cond
, &bql
);
552 void qemu_cond_timedwait_bql(QemuCond
*cond
, int ms
)
554 qemu_cond_timedwait(cond
, &bql
, ms
);
557 /* signal CPU creation */
558 void cpu_thread_signal_created(CPUState
*cpu
)
561 qemu_cond_signal(&qemu_cpu_cond
);
564 /* signal CPU destruction */
565 void cpu_thread_signal_destroyed(CPUState
*cpu
)
567 cpu
->created
= false;
568 qemu_cond_signal(&qemu_cpu_cond
);
572 static bool all_vcpus_paused(void)
585 void pause_all_vcpus(void)
589 qemu_clock_enable(QEMU_CLOCK_VIRTUAL
, false);
591 if (qemu_cpu_is_self(cpu
)) {
592 qemu_cpu_stop(cpu
, true);
599 /* We need to drop the replay_lock so any vCPU threads woken up
600 * can finish their replay tasks
602 replay_mutex_unlock();
604 while (!all_vcpus_paused()) {
605 qemu_cond_wait(&qemu_pause_cond
, &bql
);
616 void cpu_resume(CPUState
*cpu
)
619 cpu
->stopped
= false;
623 void resume_all_vcpus(void)
627 if (!runstate_is_running()) {
631 qemu_clock_enable(QEMU_CLOCK_VIRTUAL
, true);
637 void cpu_remove_sync(CPUState
*cpu
)
643 qemu_thread_join(cpu
->thread
);
647 void cpus_register_accel(const AccelOpsClass
*ops
)
650 assert(ops
->create_vcpu_thread
!= NULL
); /* mandatory */
654 const AccelOpsClass
*cpus_get_accel(void)
656 /* broken if we call this early */
661 void qemu_init_vcpu(CPUState
*cpu
)
663 MachineState
*ms
= MACHINE(qdev_get_machine());
665 cpu
->nr_cores
= machine_topo_get_cores_per_socket(ms
);
666 cpu
->nr_threads
= ms
->smp
.threads
;
668 cpu
->random_seed
= qemu_guest_random_seed_thread_part1();
671 /* If the target cpu hasn't set up any address spaces itself,
672 * give it the default one.
675 cpu_address_space_init(cpu
, 0, "cpu-memory", cpu
->memory
);
678 /* accelerators all implement the AccelOpsClass */
679 g_assert(cpus_accel
!= NULL
&& cpus_accel
->create_vcpu_thread
!= NULL
);
680 cpus_accel
->create_vcpu_thread(cpu
);
682 while (!cpu
->created
) {
683 qemu_cond_wait(&qemu_cpu_cond
, &bql
);
687 void cpu_stop_current(void)
690 current_cpu
->stop
= true;
691 cpu_exit(current_cpu
);
695 int vm_stop(RunState state
)
697 if (qemu_in_vcpu_thread()) {
698 qemu_system_vmstop_request_prepare();
699 qemu_system_vmstop_request(state
);
701 * FIXME: should not return to device code in case
702 * vm_stop() has been requested.
708 return do_vm_stop(state
, true);
712 * Prepare for (re)starting the VM.
713 * Returns 0 if the vCPUs should be restarted, -1 on an error condition,
716 int vm_prepare_start(bool step_pending
)
718 int ret
= vm_was_suspended
? 1 : 0;
719 RunState state
= vm_was_suspended
? RUN_STATE_SUSPENDED
: RUN_STATE_RUNNING
;
722 qemu_vmstop_requested(&requested
);
723 if (runstate_is_running() && requested
== RUN_STATE__MAX
) {
727 /* Ensure that a STOP/RESUME pair of events is emitted if a
728 * vmstop request was pending. The BLOCK_IO_ERROR event, for
729 * example, according to documentation is always followed by
732 if (runstate_is_running()) {
733 qapi_event_send_stop();
734 qapi_event_send_resume();
739 * WHPX accelerator needs to know whether we are going to step
740 * any CPUs, before starting the first one.
742 if (cpus_accel
->synchronize_pre_resume
) {
743 cpus_accel
->synchronize_pre_resume(step_pending
);
746 /* We are sending this now, but the CPUs will be resumed shortly later */
747 qapi_event_send_resume();
751 vm_state_notify(1, state
);
752 vm_was_suspended
= false;
758 if (!vm_prepare_start(false)) {
763 void vm_resume(RunState state
)
765 if (runstate_is_live(state
)) {
772 /* does a state transition even if the VM is already stopped,
773 current state is forgotten forever */
774 int vm_stop_force_state(RunState state
)
776 if (runstate_is_live(runstate_get())) {
777 return vm_stop(state
);
783 /* Make sure to return an error if the flush in a previous vm_stop()
785 ret
= bdrv_flush_all();
786 trace_vm_stop_flush_all(ret
);
791 void qmp_memsave(int64_t addr
, int64_t size
, const char *filename
,
792 bool has_cpu
, int64_t cpu_index
, Error
**errp
)
798 int64_t orig_addr
= addr
, orig_size
= size
;
804 cpu
= qemu_get_cpu(cpu_index
);
806 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "cpu-index",
811 f
= fopen(filename
, "wb");
813 error_setg_file_open(errp
, errno
, filename
);
821 if (cpu_memory_rw_debug(cpu
, addr
, buf
, l
, 0) != 0) {
822 error_setg(errp
, "Invalid addr 0x%016" PRIx64
"/size %" PRId64
823 " specified", orig_addr
, orig_size
);
826 if (fwrite(buf
, 1, l
, f
) != l
) {
827 error_setg(errp
, "writing memory to '%s' failed",
839 void qmp_pmemsave(int64_t addr
, int64_t size
, const char *filename
,
846 f
= fopen(filename
, "wb");
848 error_setg_file_open(errp
, errno
, filename
);
856 cpu_physical_memory_read(addr
, buf
, l
);
857 if (fwrite(buf
, 1, l
, f
) != l
) {
858 error_setg(errp
, "writing memory to '%s' failed",
870 void qmp_inject_nmi(Error
**errp
)
872 nmi_monitor_handle(monitor_get_cpu_index(monitor_cur()), errp
);