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 "qemu-common.h"
27 #include "monitor/monitor.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/exec-all.h"
36 #include "qemu/thread.h"
37 #include "qemu/plugin.h"
38 #include "sysemu/cpus.h"
39 #include "qemu/guest-random.h"
41 #include "sysemu/replay.h"
42 #include "sysemu/runstate.h"
43 #include "sysemu/cpu-timers.h"
44 #include "sysemu/whpx.h"
45 #include "hw/boards.h"
50 #include <sys/prctl.h>
53 #define PR_MCE_KILL 33
56 #ifndef PR_MCE_KILL_SET
57 #define PR_MCE_KILL_SET 1
60 #ifndef PR_MCE_KILL_EARLY
61 #define PR_MCE_KILL_EARLY 1
64 #endif /* CONFIG_LINUX */
66 static QemuMutex qemu_global_mutex;
68 bool cpu_is_stopped(CPUState *cpu)
70 return cpu->stopped || !runstate_is_running();
73 bool cpu_work_list_empty(CPUState *cpu)
77 qemu_mutex_lock(&cpu->work_mutex);
78 ret = QSIMPLEQ_EMPTY(&cpu->work_list);
79 qemu_mutex_unlock(&cpu->work_mutex);
83 bool cpu_thread_is_idle(CPUState *cpu)
85 if (cpu->stop || !cpu_work_list_empty(cpu)) {
88 if (cpu_is_stopped(cpu)) {
91 if (!cpu->halted || cpu_has_work(cpu) ||
92 kvm_halt_in_kernel() || whpx_apic_in_platform()) {
98 bool all_cpu_threads_idle(void)
103 if (!cpu_thread_is_idle(cpu)) {
110 /***********************************************************/
111 void hw_error(const char *fmt, ...)
117 fprintf(stderr, "qemu: hardware error: ");
118 vfprintf(stderr, fmt, ap);
119 fprintf(stderr, "\n");
121 fprintf(stderr, "CPU #%d:\n", cpu->cpu_index);
122 cpu_dump_state(cpu, stderr, CPU_DUMP_FPU);
129 * The chosen accelerator is supposed to register this.
131 static const AccelOpsClass *cpus_accel;
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 int64_t cpus_get_virtual_clock(void)
202 * need to check that cpus_accel is not NULL, because qcow2 calls
203 * qemu_get_clock_ns(CLOCK_VIRTUAL) without any accel initialized and
204 * with ticks disabled in some io-tests:
205 * 030 040 041 060 099 120 127 140 156 161 172 181 191 192 195 203 229 249 256 267
211 if (cpus_accel && cpus_accel->get_virtual_clock) {
212 return cpus_accel->get_virtual_clock();
214 return cpu_get_clock();
218 * return the time elapsed in VM between vm_start and vm_stop. Unless
219 * icount is active, cpus_get_elapsed_ticks() uses units of the host CPU cycle
222 int64_t cpus_get_elapsed_ticks(void)
224 if (cpus_accel->get_elapsed_ticks) {
225 return cpus_accel->get_elapsed_ticks();
227 return cpu_get_ticks();
230 static void generic_handle_interrupt(CPUState *cpu, int mask)
232 cpu->interrupt_request |= mask;
234 if (!qemu_cpu_is_self(cpu)) {
239 void cpu_interrupt(CPUState *cpu, int mask)
241 if (cpus_accel->handle_interrupt) {
242 cpus_accel->handle_interrupt(cpu, mask);
244 generic_handle_interrupt(cpu, mask);
248 static int do_vm_stop(RunState state, bool send_stop)
252 if (runstate_is_running()) {
256 vm_state_notify(0, state);
258 qapi_event_send_stop();
263 ret = bdrv_flush_all();
268 /* Special vm_stop() variant for terminating the process. Historically clients
269 * did not expect a QMP STOP event and so we need to retain compatibility.
271 int vm_shutdown(void)
273 return do_vm_stop(RUN_STATE_SHUTDOWN, false);
276 bool cpu_can_run(CPUState *cpu)
281 if (cpu_is_stopped(cpu)) {
287 void cpu_handle_guest_debug(CPUState *cpu)
289 if (replay_running_debug()) {
290 if (!cpu->singlestep_enabled) {
292 * Report about the breakpoint and
293 * make a single step to skip it
296 cpu_single_step(cpu, SSTEP_ENABLE);
298 cpu_single_step(cpu, 0);
301 gdb_set_stop_cpu(cpu);
302 qemu_system_debug_request();
308 static void sigbus_reraise(void)
311 struct sigaction action;
313 memset(&action, 0, sizeof(action));
314 action.sa_handler = SIG_DFL;
315 if (!sigaction(SIGBUS, &action, NULL)) {
318 sigaddset(&set, SIGBUS);
319 pthread_sigmask(SIG_UNBLOCK, &set, NULL);
321 perror("Failed to re-raise SIGBUS!\n");
325 static void sigbus_handler(int n, siginfo_t *siginfo, void *ctx)
327 if (siginfo->si_code != BUS_MCEERR_AO && siginfo->si_code != BUS_MCEERR_AR) {
332 /* Called asynchronously in VCPU thread. */
333 if (kvm_on_sigbus_vcpu(current_cpu, siginfo->si_code, siginfo->si_addr)) {
337 /* Called synchronously (via signalfd) in main thread. */
338 if (kvm_on_sigbus(siginfo->si_code, siginfo->si_addr)) {
344 static void qemu_init_sigbus(void)
346 struct sigaction action;
348 memset(&action, 0, sizeof(action));
349 action.sa_flags = SA_SIGINFO;
350 action.sa_sigaction = sigbus_handler;
351 sigaction(SIGBUS, &action, NULL);
353 prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, 0, 0);
355 #else /* !CONFIG_LINUX */
356 static void qemu_init_sigbus(void)
359 #endif /* !CONFIG_LINUX */
361 static QemuThread io_thread;
364 static QemuCond qemu_cpu_cond;
366 static QemuCond qemu_pause_cond;
368 void qemu_init_cpu_loop(void)
371 qemu_cond_init(&qemu_cpu_cond);
372 qemu_cond_init(&qemu_pause_cond);
373 qemu_mutex_init(&qemu_global_mutex);
375 qemu_thread_get_self(&io_thread);
378 void run_on_cpu(CPUState *cpu, run_on_cpu_func func, run_on_cpu_data data)
380 do_run_on_cpu(cpu, func, data, &qemu_global_mutex);
383 static void qemu_cpu_stop(CPUState *cpu, bool exit)
385 g_assert(qemu_cpu_is_self(cpu));
391 qemu_cond_broadcast(&qemu_pause_cond);
394 void qemu_wait_io_event_common(CPUState *cpu)
396 qatomic_mb_set(&cpu->thread_kicked, false);
398 qemu_cpu_stop(cpu, false);
400 process_queued_cpu_work(cpu);
403 void qemu_wait_io_event(CPUState *cpu)
407 while (cpu_thread_is_idle(cpu)) {
410 qemu_plugin_vcpu_idle_cb(cpu);
412 qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
415 qemu_plugin_vcpu_resume_cb(cpu);
419 /* Eat dummy APC queued by cpus_kick_thread. */
424 qemu_wait_io_event_common(cpu);
427 void cpus_kick_thread(CPUState *cpu)
432 if (cpu->thread_kicked) {
435 cpu->thread_kicked = true;
436 err = pthread_kill(cpu->thread->thread, SIG_IPI);
437 if (err && err != ESRCH) {
438 fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
444 void qemu_cpu_kick(CPUState *cpu)
446 qemu_cond_broadcast(cpu->halt_cond);
447 if (cpus_accel->kick_vcpu_thread) {
448 cpus_accel->kick_vcpu_thread(cpu);
449 } else { /* default */
450 cpus_kick_thread(cpu);
454 void qemu_cpu_kick_self(void)
457 cpus_kick_thread(current_cpu);
460 bool qemu_cpu_is_self(CPUState *cpu)
462 return qemu_thread_is_self(cpu->thread);
465 bool qemu_in_vcpu_thread(void)
467 return current_cpu && qemu_cpu_is_self(current_cpu);
470 static __thread bool iothread_locked = false;
472 bool qemu_mutex_iothread_locked(void)
474 return iothread_locked;
478 * The BQL is taken from so many places that it is worth profiling the
479 * callers directly, instead of funneling them all through a single function.
481 void qemu_mutex_lock_iothread_impl(const char *file, int line)
483 QemuMutexLockFunc bql_lock = qatomic_read(&qemu_bql_mutex_lock_func);
485 g_assert(!qemu_mutex_iothread_locked());
486 bql_lock(&qemu_global_mutex, file, line);
487 iothread_locked = true;
490 void qemu_mutex_unlock_iothread(void)
492 g_assert(qemu_mutex_iothread_locked());
493 iothread_locked = false;
494 qemu_mutex_unlock(&qemu_global_mutex);
497 void qemu_cond_wait_iothread(QemuCond *cond)
499 qemu_cond_wait(cond, &qemu_global_mutex);
502 void qemu_cond_timedwait_iothread(QemuCond *cond, int ms)
504 qemu_cond_timedwait(cond, &qemu_global_mutex, ms);
507 /* signal CPU creation */
508 void cpu_thread_signal_created(CPUState *cpu)
511 qemu_cond_signal(&qemu_cpu_cond);
514 /* signal CPU destruction */
515 void cpu_thread_signal_destroyed(CPUState *cpu)
517 cpu->created = false;
518 qemu_cond_signal(&qemu_cpu_cond);
522 static bool all_vcpus_paused(void)
535 void pause_all_vcpus(void)
539 qemu_clock_enable(QEMU_CLOCK_VIRTUAL, false);
541 if (qemu_cpu_is_self(cpu)) {
542 qemu_cpu_stop(cpu, true);
549 /* We need to drop the replay_lock so any vCPU threads woken up
550 * can finish their replay tasks
552 replay_mutex_unlock();
554 while (!all_vcpus_paused()) {
555 qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
561 qemu_mutex_unlock_iothread();
563 qemu_mutex_lock_iothread();
566 void cpu_resume(CPUState *cpu)
569 cpu->stopped = false;
573 void resume_all_vcpus(void)
577 if (!runstate_is_running()) {
581 qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
587 void cpu_remove_sync(CPUState *cpu)
592 qemu_mutex_unlock_iothread();
593 qemu_thread_join(cpu->thread);
594 qemu_mutex_lock_iothread();
597 void cpus_register_accel(const AccelOpsClass *ops)
600 assert(ops->create_vcpu_thread != NULL); /* mandatory */
604 void qemu_init_vcpu(CPUState *cpu)
606 MachineState *ms = MACHINE(qdev_get_machine());
608 cpu->nr_cores = ms->smp.cores;
609 cpu->nr_threads = ms->smp.threads;
611 cpu->random_seed = qemu_guest_random_seed_thread_part1();
614 /* If the target cpu hasn't set up any address spaces itself,
615 * give it the default one.
618 cpu_address_space_init(cpu, 0, "cpu-memory", cpu->memory);
621 /* accelerators all implement the AccelOpsClass */
622 g_assert(cpus_accel != NULL && cpus_accel->create_vcpu_thread != NULL);
623 cpus_accel->create_vcpu_thread(cpu);
625 while (!cpu->created) {
626 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
630 void cpu_stop_current(void)
633 current_cpu->stop = true;
634 cpu_exit(current_cpu);
638 int vm_stop(RunState state)
640 if (qemu_in_vcpu_thread()) {
641 qemu_system_vmstop_request_prepare();
642 qemu_system_vmstop_request(state);
644 * FIXME: should not return to device code in case
645 * vm_stop() has been requested.
651 return do_vm_stop(state, true);
655 * Prepare for (re)starting the VM.
656 * Returns -1 if the vCPUs are not to be restarted (e.g. if they are already
657 * running or in case of an error condition), 0 otherwise.
659 int vm_prepare_start(void)
663 qemu_vmstop_requested(&requested);
664 if (runstate_is_running() && requested == RUN_STATE__MAX) {
668 /* Ensure that a STOP/RESUME pair of events is emitted if a
669 * vmstop request was pending. The BLOCK_IO_ERROR event, for
670 * example, according to documentation is always followed by
673 if (runstate_is_running()) {
674 qapi_event_send_stop();
675 qapi_event_send_resume();
679 /* We are sending this now, but the CPUs will be resumed shortly later */
680 qapi_event_send_resume();
683 runstate_set(RUN_STATE_RUNNING);
684 vm_state_notify(1, RUN_STATE_RUNNING);
690 if (!vm_prepare_start()) {
695 /* does a state transition even if the VM is already stopped,
696 current state is forgotten forever */
697 int vm_stop_force_state(RunState state)
699 if (runstate_is_running()) {
700 return vm_stop(state);
705 /* Make sure to return an error if the flush in a previous vm_stop()
707 return bdrv_flush_all();
711 void list_cpus(const char *optarg)
713 /* XXX: implement xxx_cpu_list for targets that still miss it */
714 #if defined(cpu_list)
719 void qmp_memsave(int64_t addr, int64_t size, const char *filename,
720 bool has_cpu, int64_t cpu_index, Error **errp)
726 int64_t orig_addr = addr, orig_size = size;
732 cpu = qemu_get_cpu(cpu_index);
734 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
739 f = fopen(filename, "wb");
741 error_setg_file_open(errp, errno, filename);
749 if (cpu_memory_rw_debug(cpu, addr, buf, l, 0) != 0) {
750 error_setg(errp, "Invalid addr 0x%016" PRIx64 "/size %" PRId64
751 " specified", orig_addr, orig_size);
754 if (fwrite(buf, 1, l, f) != l) {
755 error_setg(errp, QERR_IO_ERROR);
766 void qmp_pmemsave(int64_t addr, int64_t size, const char *filename,
773 f = fopen(filename, "wb");
775 error_setg_file_open(errp, errno, filename);
783 cpu_physical_memory_read(addr, buf, l);
784 if (fwrite(buf, 1, l, f) != l) {
785 error_setg(errp, QERR_IO_ERROR);
796 void qmp_inject_nmi(Error **errp)
798 nmi_monitor_handle(monitor_get_cpu_index(monitor_cur()), errp);