| /* |
| * QEMU main system emulation loop |
| * |
| * Copyright (c) 2003-2020 QEMU contributors |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to deal |
| * in the Software without restriction, including without limitation the rights |
| * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| * copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| * THE SOFTWARE. |
| */ |
| |
| #include "qemu/osdep.h" |
| #include "audio/audio.h" |
| #include "block/block.h" |
| #include "block/export.h" |
| #include "chardev/char.h" |
| #include "crypto/cipher.h" |
| #include "crypto/init.h" |
| #include "exec/cpu-common.h" |
| #include "exec/exec-all.h" |
| #include "exec/gdbstub.h" |
| #include "hw/boards.h" |
| #include "migration/misc.h" |
| #include "migration/postcopy-ram.h" |
| #include "monitor/monitor.h" |
| #include "net/net.h" |
| #include "net/vhost_net.h" |
| #include "qapi/error.h" |
| #include "qapi/qapi-commands-run-state.h" |
| #include "qapi/qapi-events-run-state.h" |
| #include "qemu-common.h" |
| #include "qemu/error-report.h" |
| #include "qemu/job.h" |
| #include "qemu/module.h" |
| #include "qemu/plugin.h" |
| #include "qemu/sockets.h" |
| #include "qemu/thread.h" |
| #include "qom/object.h" |
| #include "qom/object_interfaces.h" |
| #include "sysemu/cpus.h" |
| #include "sysemu/qtest.h" |
| #include "sysemu/replay.h" |
| #include "sysemu/reset.h" |
| #include "sysemu/runstate.h" |
| #include "sysemu/runstate-action.h" |
| #include "sysemu/sysemu.h" |
| #include "sysemu/tpm.h" |
| #include "trace.h" |
| |
| static NotifierList exit_notifiers = |
| NOTIFIER_LIST_INITIALIZER(exit_notifiers); |
| |
| static RunState current_run_state = RUN_STATE_PRELAUNCH; |
| |
| /* We use RUN_STATE__MAX but any invalid value will do */ |
| static RunState vmstop_requested = RUN_STATE__MAX; |
| static QemuMutex vmstop_lock; |
| |
| typedef struct { |
| RunState from; |
| RunState to; |
| } RunStateTransition; |
| |
| static const RunStateTransition runstate_transitions_def[] = { |
| { RUN_STATE_PRELAUNCH, RUN_STATE_INMIGRATE }, |
| |
| { RUN_STATE_DEBUG, RUN_STATE_RUNNING }, |
| { RUN_STATE_DEBUG, RUN_STATE_FINISH_MIGRATE }, |
| { RUN_STATE_DEBUG, RUN_STATE_PRELAUNCH }, |
| |
| { RUN_STATE_INMIGRATE, RUN_STATE_INTERNAL_ERROR }, |
| { RUN_STATE_INMIGRATE, RUN_STATE_IO_ERROR }, |
| { RUN_STATE_INMIGRATE, RUN_STATE_PAUSED }, |
| { RUN_STATE_INMIGRATE, RUN_STATE_RUNNING }, |
| { RUN_STATE_INMIGRATE, RUN_STATE_SHUTDOWN }, |
| { RUN_STATE_INMIGRATE, RUN_STATE_SUSPENDED }, |
| { RUN_STATE_INMIGRATE, RUN_STATE_WATCHDOG }, |
| { RUN_STATE_INMIGRATE, RUN_STATE_GUEST_PANICKED }, |
| { RUN_STATE_INMIGRATE, RUN_STATE_FINISH_MIGRATE }, |
| { RUN_STATE_INMIGRATE, RUN_STATE_PRELAUNCH }, |
| { RUN_STATE_INMIGRATE, RUN_STATE_POSTMIGRATE }, |
| { RUN_STATE_INMIGRATE, RUN_STATE_COLO }, |
| |
| { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PAUSED }, |
| { RUN_STATE_INTERNAL_ERROR, RUN_STATE_FINISH_MIGRATE }, |
| { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PRELAUNCH }, |
| |
| { RUN_STATE_IO_ERROR, RUN_STATE_RUNNING }, |
| { RUN_STATE_IO_ERROR, RUN_STATE_FINISH_MIGRATE }, |
| { RUN_STATE_IO_ERROR, RUN_STATE_PRELAUNCH }, |
| |
| { RUN_STATE_PAUSED, RUN_STATE_RUNNING }, |
| { RUN_STATE_PAUSED, RUN_STATE_FINISH_MIGRATE }, |
| { RUN_STATE_PAUSED, RUN_STATE_POSTMIGRATE }, |
| { RUN_STATE_PAUSED, RUN_STATE_PRELAUNCH }, |
| { RUN_STATE_PAUSED, RUN_STATE_COLO}, |
| |
| { RUN_STATE_POSTMIGRATE, RUN_STATE_RUNNING }, |
| { RUN_STATE_POSTMIGRATE, RUN_STATE_FINISH_MIGRATE }, |
| { RUN_STATE_POSTMIGRATE, RUN_STATE_PRELAUNCH }, |
| |
| { RUN_STATE_PRELAUNCH, RUN_STATE_RUNNING }, |
| { RUN_STATE_PRELAUNCH, RUN_STATE_FINISH_MIGRATE }, |
| { RUN_STATE_PRELAUNCH, RUN_STATE_INMIGRATE }, |
| |
| { RUN_STATE_FINISH_MIGRATE, RUN_STATE_RUNNING }, |
| { RUN_STATE_FINISH_MIGRATE, RUN_STATE_PAUSED }, |
| { RUN_STATE_FINISH_MIGRATE, RUN_STATE_POSTMIGRATE }, |
| { RUN_STATE_FINISH_MIGRATE, RUN_STATE_PRELAUNCH }, |
| { RUN_STATE_FINISH_MIGRATE, RUN_STATE_COLO}, |
| |
| { RUN_STATE_RESTORE_VM, RUN_STATE_RUNNING }, |
| { RUN_STATE_RESTORE_VM, RUN_STATE_PRELAUNCH }, |
| |
| { RUN_STATE_COLO, RUN_STATE_RUNNING }, |
| { RUN_STATE_COLO, RUN_STATE_SHUTDOWN}, |
| |
| { RUN_STATE_RUNNING, RUN_STATE_DEBUG }, |
| { RUN_STATE_RUNNING, RUN_STATE_INTERNAL_ERROR }, |
| { RUN_STATE_RUNNING, RUN_STATE_IO_ERROR }, |
| { RUN_STATE_RUNNING, RUN_STATE_PAUSED }, |
| { RUN_STATE_RUNNING, RUN_STATE_FINISH_MIGRATE }, |
| { RUN_STATE_RUNNING, RUN_STATE_RESTORE_VM }, |
| { RUN_STATE_RUNNING, RUN_STATE_SAVE_VM }, |
| { RUN_STATE_RUNNING, RUN_STATE_SHUTDOWN }, |
| { RUN_STATE_RUNNING, RUN_STATE_WATCHDOG }, |
| { RUN_STATE_RUNNING, RUN_STATE_GUEST_PANICKED }, |
| { RUN_STATE_RUNNING, RUN_STATE_COLO}, |
| |
| { RUN_STATE_SAVE_VM, RUN_STATE_RUNNING }, |
| |
| { RUN_STATE_SHUTDOWN, RUN_STATE_PAUSED }, |
| { RUN_STATE_SHUTDOWN, RUN_STATE_FINISH_MIGRATE }, |
| { RUN_STATE_SHUTDOWN, RUN_STATE_PRELAUNCH }, |
| { RUN_STATE_SHUTDOWN, RUN_STATE_COLO }, |
| |
| { RUN_STATE_DEBUG, RUN_STATE_SUSPENDED }, |
| { RUN_STATE_RUNNING, RUN_STATE_SUSPENDED }, |
| { RUN_STATE_SUSPENDED, RUN_STATE_RUNNING }, |
| { RUN_STATE_SUSPENDED, RUN_STATE_FINISH_MIGRATE }, |
| { RUN_STATE_SUSPENDED, RUN_STATE_PRELAUNCH }, |
| { RUN_STATE_SUSPENDED, RUN_STATE_COLO}, |
| |
| { RUN_STATE_WATCHDOG, RUN_STATE_RUNNING }, |
| { RUN_STATE_WATCHDOG, RUN_STATE_FINISH_MIGRATE }, |
| { RUN_STATE_WATCHDOG, RUN_STATE_PRELAUNCH }, |
| { RUN_STATE_WATCHDOG, RUN_STATE_COLO}, |
| |
| { RUN_STATE_GUEST_PANICKED, RUN_STATE_RUNNING }, |
| { RUN_STATE_GUEST_PANICKED, RUN_STATE_FINISH_MIGRATE }, |
| { RUN_STATE_GUEST_PANICKED, RUN_STATE_PRELAUNCH }, |
| |
| { RUN_STATE__MAX, RUN_STATE__MAX }, |
| }; |
| |
| static bool runstate_valid_transitions[RUN_STATE__MAX][RUN_STATE__MAX]; |
| |
| bool runstate_check(RunState state) |
| { |
| return current_run_state == state; |
| } |
| |
| bool runstate_store(char *str, size_t size) |
| { |
| const char *state = RunState_str(current_run_state); |
| size_t len = strlen(state) + 1; |
| |
| if (len > size) { |
| return false; |
| } |
| memcpy(str, state, len); |
| return true; |
| } |
| |
| static void runstate_init(void) |
| { |
| const RunStateTransition *p; |
| |
| memset(&runstate_valid_transitions, 0, sizeof(runstate_valid_transitions)); |
| for (p = &runstate_transitions_def[0]; p->from != RUN_STATE__MAX; p++) { |
| runstate_valid_transitions[p->from][p->to] = true; |
| } |
| |
| qemu_mutex_init(&vmstop_lock); |
| } |
| |
| /* This function will abort() on invalid state transitions */ |
| void runstate_set(RunState new_state) |
| { |
| assert(new_state < RUN_STATE__MAX); |
| |
| trace_runstate_set(current_run_state, RunState_str(current_run_state), |
| new_state, RunState_str(new_state)); |
| |
| if (current_run_state == new_state) { |
| return; |
| } |
| |
| if (!runstate_valid_transitions[current_run_state][new_state]) { |
| error_report("invalid runstate transition: '%s' -> '%s'", |
| RunState_str(current_run_state), |
| RunState_str(new_state)); |
| abort(); |
| } |
| |
| current_run_state = new_state; |
| } |
| |
| bool runstate_is_running(void) |
| { |
| return runstate_check(RUN_STATE_RUNNING); |
| } |
| |
| bool runstate_needs_reset(void) |
| { |
| return runstate_check(RUN_STATE_INTERNAL_ERROR) || |
| runstate_check(RUN_STATE_SHUTDOWN); |
| } |
| |
| StatusInfo *qmp_query_status(Error **errp) |
| { |
| StatusInfo *info = g_malloc0(sizeof(*info)); |
| |
| info->running = runstate_is_running(); |
| info->singlestep = singlestep; |
| info->status = current_run_state; |
| |
| return info; |
| } |
| |
| bool qemu_vmstop_requested(RunState *r) |
| { |
| qemu_mutex_lock(&vmstop_lock); |
| *r = vmstop_requested; |
| vmstop_requested = RUN_STATE__MAX; |
| qemu_mutex_unlock(&vmstop_lock); |
| return *r < RUN_STATE__MAX; |
| } |
| |
| void qemu_system_vmstop_request_prepare(void) |
| { |
| qemu_mutex_lock(&vmstop_lock); |
| } |
| |
| void qemu_system_vmstop_request(RunState state) |
| { |
| vmstop_requested = state; |
| qemu_mutex_unlock(&vmstop_lock); |
| qemu_notify_event(); |
| } |
| struct VMChangeStateEntry { |
| VMChangeStateHandler *cb; |
| void *opaque; |
| QTAILQ_ENTRY(VMChangeStateEntry) entries; |
| int priority; |
| }; |
| |
| static QTAILQ_HEAD(, VMChangeStateEntry) vm_change_state_head = |
| QTAILQ_HEAD_INITIALIZER(vm_change_state_head); |
| |
| /** |
| * qemu_add_vm_change_state_handler_prio: |
| * @cb: the callback to invoke |
| * @opaque: user data passed to the callback |
| * @priority: low priorities execute first when the vm runs and the reverse is |
| * true when the vm stops |
| * |
| * Register a callback function that is invoked when the vm starts or stops |
| * running. |
| * |
| * Returns: an entry to be freed using qemu_del_vm_change_state_handler() |
| */ |
| VMChangeStateEntry *qemu_add_vm_change_state_handler_prio( |
| VMChangeStateHandler *cb, void *opaque, int priority) |
| { |
| VMChangeStateEntry *e; |
| VMChangeStateEntry *other; |
| |
| e = g_malloc0(sizeof(*e)); |
| e->cb = cb; |
| e->opaque = opaque; |
| e->priority = priority; |
| |
| /* Keep list sorted in ascending priority order */ |
| QTAILQ_FOREACH(other, &vm_change_state_head, entries) { |
| if (priority < other->priority) { |
| QTAILQ_INSERT_BEFORE(other, e, entries); |
| return e; |
| } |
| } |
| |
| QTAILQ_INSERT_TAIL(&vm_change_state_head, e, entries); |
| return e; |
| } |
| |
| VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb, |
| void *opaque) |
| { |
| return qemu_add_vm_change_state_handler_prio(cb, opaque, 0); |
| } |
| |
| void qemu_del_vm_change_state_handler(VMChangeStateEntry *e) |
| { |
| QTAILQ_REMOVE(&vm_change_state_head, e, entries); |
| g_free(e); |
| } |
| |
| void vm_state_notify(bool running, RunState state) |
| { |
| VMChangeStateEntry *e, *next; |
| |
| trace_vm_state_notify(running, state, RunState_str(state)); |
| |
| if (running) { |
| QTAILQ_FOREACH_SAFE(e, &vm_change_state_head, entries, next) { |
| e->cb(e->opaque, running, state); |
| } |
| } else { |
| QTAILQ_FOREACH_REVERSE_SAFE(e, &vm_change_state_head, entries, next) { |
| e->cb(e->opaque, running, state); |
| } |
| } |
| } |
| |
| static ShutdownCause reset_requested; |
| static ShutdownCause shutdown_requested; |
| static int shutdown_signal; |
| static pid_t shutdown_pid; |
| static int powerdown_requested; |
| static int debug_requested; |
| static int suspend_requested; |
| static WakeupReason wakeup_reason; |
| static NotifierList powerdown_notifiers = |
| NOTIFIER_LIST_INITIALIZER(powerdown_notifiers); |
| static NotifierList suspend_notifiers = |
| NOTIFIER_LIST_INITIALIZER(suspend_notifiers); |
| static NotifierList wakeup_notifiers = |
| NOTIFIER_LIST_INITIALIZER(wakeup_notifiers); |
| static NotifierList shutdown_notifiers = |
| NOTIFIER_LIST_INITIALIZER(shutdown_notifiers); |
| static uint32_t wakeup_reason_mask = ~(1 << QEMU_WAKEUP_REASON_NONE); |
| |
| ShutdownCause qemu_shutdown_requested_get(void) |
| { |
| return shutdown_requested; |
| } |
| |
| ShutdownCause qemu_reset_requested_get(void) |
| { |
| return reset_requested; |
| } |
| |
| static int qemu_shutdown_requested(void) |
| { |
| return qatomic_xchg(&shutdown_requested, SHUTDOWN_CAUSE_NONE); |
| } |
| |
| static void qemu_kill_report(void) |
| { |
| if (!qtest_driver() && shutdown_signal) { |
| if (shutdown_pid == 0) { |
| /* This happens for eg ^C at the terminal, so it's worth |
| * avoiding printing an odd message in that case. |
| */ |
| error_report("terminating on signal %d", shutdown_signal); |
| } else { |
| char *shutdown_cmd = qemu_get_pid_name(shutdown_pid); |
| |
| error_report("terminating on signal %d from pid " FMT_pid " (%s)", |
| shutdown_signal, shutdown_pid, |
| shutdown_cmd ? shutdown_cmd : "<unknown process>"); |
| g_free(shutdown_cmd); |
| } |
| shutdown_signal = 0; |
| } |
| } |
| |
| static ShutdownCause qemu_reset_requested(void) |
| { |
| ShutdownCause r = reset_requested; |
| |
| if (r && replay_checkpoint(CHECKPOINT_RESET_REQUESTED)) { |
| reset_requested = SHUTDOWN_CAUSE_NONE; |
| return r; |
| } |
| return SHUTDOWN_CAUSE_NONE; |
| } |
| |
| static int qemu_suspend_requested(void) |
| { |
| int r = suspend_requested; |
| if (r && replay_checkpoint(CHECKPOINT_SUSPEND_REQUESTED)) { |
| suspend_requested = 0; |
| return r; |
| } |
| return false; |
| } |
| |
| static WakeupReason qemu_wakeup_requested(void) |
| { |
| return wakeup_reason; |
| } |
| |
| static int qemu_powerdown_requested(void) |
| { |
| int r = powerdown_requested; |
| powerdown_requested = 0; |
| return r; |
| } |
| |
| static int qemu_debug_requested(void) |
| { |
| int r = debug_requested; |
| debug_requested = 0; |
| return r; |
| } |
| |
| /* |
| * Reset the VM. Issue an event unless @reason is SHUTDOWN_CAUSE_NONE. |
| */ |
| void qemu_system_reset(ShutdownCause reason) |
| { |
| MachineClass *mc; |
| |
| mc = current_machine ? MACHINE_GET_CLASS(current_machine) : NULL; |
| |
| cpu_synchronize_all_states(); |
| |
| if (mc && mc->reset) { |
| mc->reset(current_machine); |
| } else { |
| qemu_devices_reset(); |
| } |
| if (reason && reason != SHUTDOWN_CAUSE_SUBSYSTEM_RESET) { |
| qapi_event_send_reset(shutdown_caused_by_guest(reason), reason); |
| } |
| cpu_synchronize_all_post_reset(); |
| } |
| |
| /* |
| * Wake the VM after suspend. |
| */ |
| static void qemu_system_wakeup(void) |
| { |
| MachineClass *mc; |
| |
| mc = current_machine ? MACHINE_GET_CLASS(current_machine) : NULL; |
| |
| if (mc && mc->wakeup) { |
| mc->wakeup(current_machine); |
| } |
| } |
| |
| void qemu_system_guest_panicked(GuestPanicInformation *info) |
| { |
| qemu_log_mask(LOG_GUEST_ERROR, "Guest crashed"); |
| |
| if (current_cpu) { |
| current_cpu->crash_occurred = true; |
| } |
| /* |
| * TODO: Currently the available panic actions are: none, pause, and |
| * shutdown, but in principle debug and reset could be supported as well. |
| * Investigate any potential use cases for the unimplemented actions. |
| */ |
| if (panic_action == PANIC_ACTION_PAUSE |
| || (panic_action == PANIC_ACTION_SHUTDOWN && shutdown_action == SHUTDOWN_ACTION_PAUSE)) { |
| qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_PAUSE, |
| !!info, info); |
| vm_stop(RUN_STATE_GUEST_PANICKED); |
| } else if (panic_action == PANIC_ACTION_SHUTDOWN) { |
| qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_POWEROFF, |
| !!info, info); |
| vm_stop(RUN_STATE_GUEST_PANICKED); |
| qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_PANIC); |
| } else { |
| qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_RUN, |
| !!info, info); |
| } |
| |
| if (info) { |
| if (info->type == GUEST_PANIC_INFORMATION_TYPE_HYPER_V) { |
| qemu_log_mask(LOG_GUEST_ERROR, "\nHV crash parameters: (%#"PRIx64 |
| " %#"PRIx64" %#"PRIx64" %#"PRIx64" %#"PRIx64")\n", |
| info->u.hyper_v.arg1, |
| info->u.hyper_v.arg2, |
| info->u.hyper_v.arg3, |
| info->u.hyper_v.arg4, |
| info->u.hyper_v.arg5); |
| } else if (info->type == GUEST_PANIC_INFORMATION_TYPE_S390) { |
| qemu_log_mask(LOG_GUEST_ERROR, " on cpu %d: %s\n" |
| "PSW: 0x%016" PRIx64 " 0x%016" PRIx64"\n", |
| info->u.s390.core, |
| S390CrashReason_str(info->u.s390.reason), |
| info->u.s390.psw_mask, |
| info->u.s390.psw_addr); |
| } |
| qapi_free_GuestPanicInformation(info); |
| } |
| } |
| |
| void qemu_system_guest_crashloaded(GuestPanicInformation *info) |
| { |
| qemu_log_mask(LOG_GUEST_ERROR, "Guest crash loaded"); |
| |
| qapi_event_send_guest_crashloaded(GUEST_PANIC_ACTION_RUN, |
| !!info, info); |
| |
| if (info) { |
| qapi_free_GuestPanicInformation(info); |
| } |
| } |
| |
| void qemu_system_reset_request(ShutdownCause reason) |
| { |
| if (reboot_action == REBOOT_ACTION_SHUTDOWN && |
| reason != SHUTDOWN_CAUSE_SUBSYSTEM_RESET) { |
| shutdown_requested = reason; |
| } else if (!cpus_are_resettable()) { |
| error_report("cpus are not resettable, terminating"); |
| shutdown_requested = reason; |
| } else { |
| reset_requested = reason; |
| } |
| cpu_stop_current(); |
| qemu_notify_event(); |
| } |
| |
| static void qemu_system_suspend(void) |
| { |
| pause_all_vcpus(); |
| notifier_list_notify(&suspend_notifiers, NULL); |
| runstate_set(RUN_STATE_SUSPENDED); |
| qapi_event_send_suspend(); |
| } |
| |
| void qemu_system_suspend_request(void) |
| { |
| if (runstate_check(RUN_STATE_SUSPENDED)) { |
| return; |
| } |
| suspend_requested = 1; |
| cpu_stop_current(); |
| qemu_notify_event(); |
| } |
| |
| void qemu_register_suspend_notifier(Notifier *notifier) |
| { |
| notifier_list_add(&suspend_notifiers, notifier); |
| } |
| |
| void qemu_system_wakeup_request(WakeupReason reason, Error **errp) |
| { |
| trace_system_wakeup_request(reason); |
| |
| if (!runstate_check(RUN_STATE_SUSPENDED)) { |
| error_setg(errp, |
| "Unable to wake up: guest is not in suspended state"); |
| return; |
| } |
| if (!(wakeup_reason_mask & (1 << reason))) { |
| return; |
| } |
| runstate_set(RUN_STATE_RUNNING); |
| wakeup_reason = reason; |
| qemu_notify_event(); |
| } |
| |
| void qemu_system_wakeup_enable(WakeupReason reason, bool enabled) |
| { |
| if (enabled) { |
| wakeup_reason_mask |= (1 << reason); |
| } else { |
| wakeup_reason_mask &= ~(1 << reason); |
| } |
| } |
| |
| void qemu_register_wakeup_notifier(Notifier *notifier) |
| { |
| notifier_list_add(&wakeup_notifiers, notifier); |
| } |
| |
| static bool wakeup_suspend_enabled; |
| |
| void qemu_register_wakeup_support(void) |
| { |
| wakeup_suspend_enabled = true; |
| } |
| |
| bool qemu_wakeup_suspend_enabled(void) |
| { |
| return wakeup_suspend_enabled; |
| } |
| |
| void qemu_system_killed(int signal, pid_t pid) |
| { |
| shutdown_signal = signal; |
| shutdown_pid = pid; |
| shutdown_action = SHUTDOWN_ACTION_POWEROFF; |
| |
| /* Cannot call qemu_system_shutdown_request directly because |
| * we are in a signal handler. |
| */ |
| shutdown_requested = SHUTDOWN_CAUSE_HOST_SIGNAL; |
| qemu_notify_event(); |
| } |
| |
| void qemu_system_shutdown_request(ShutdownCause reason) |
| { |
| trace_qemu_system_shutdown_request(reason); |
| replay_shutdown_request(reason); |
| shutdown_requested = reason; |
| qemu_notify_event(); |
| } |
| |
| static void qemu_system_powerdown(void) |
| { |
| qapi_event_send_powerdown(); |
| notifier_list_notify(&powerdown_notifiers, NULL); |
| } |
| |
| static void qemu_system_shutdown(ShutdownCause cause) |
| { |
| qapi_event_send_shutdown(shutdown_caused_by_guest(cause), cause); |
| notifier_list_notify(&shutdown_notifiers, &cause); |
| } |
| |
| void qemu_system_powerdown_request(void) |
| { |
| trace_qemu_system_powerdown_request(); |
| powerdown_requested = 1; |
| qemu_notify_event(); |
| } |
| |
| void qemu_register_powerdown_notifier(Notifier *notifier) |
| { |
| notifier_list_add(&powerdown_notifiers, notifier); |
| } |
| |
| void qemu_register_shutdown_notifier(Notifier *notifier) |
| { |
| notifier_list_add(&shutdown_notifiers, notifier); |
| } |
| |
| void qemu_system_debug_request(void) |
| { |
| debug_requested = 1; |
| qemu_notify_event(); |
| } |
| |
| static bool main_loop_should_exit(void) |
| { |
| RunState r; |
| ShutdownCause request; |
| |
| if (qemu_debug_requested()) { |
| vm_stop(RUN_STATE_DEBUG); |
| } |
| if (qemu_suspend_requested()) { |
| qemu_system_suspend(); |
| } |
| request = qemu_shutdown_requested(); |
| if (request) { |
| qemu_kill_report(); |
| qemu_system_shutdown(request); |
| if (shutdown_action == SHUTDOWN_ACTION_PAUSE) { |
| vm_stop(RUN_STATE_SHUTDOWN); |
| } else { |
| return true; |
| } |
| } |
| request = qemu_reset_requested(); |
| if (request) { |
| pause_all_vcpus(); |
| qemu_system_reset(request); |
| resume_all_vcpus(); |
| /* |
| * runstate can change in pause_all_vcpus() |
| * as iothread mutex is unlocked |
| */ |
| if (!runstate_check(RUN_STATE_RUNNING) && |
| !runstate_check(RUN_STATE_INMIGRATE) && |
| !runstate_check(RUN_STATE_FINISH_MIGRATE)) { |
| runstate_set(RUN_STATE_PRELAUNCH); |
| } |
| } |
| if (qemu_wakeup_requested()) { |
| pause_all_vcpus(); |
| qemu_system_wakeup(); |
| notifier_list_notify(&wakeup_notifiers, &wakeup_reason); |
| wakeup_reason = QEMU_WAKEUP_REASON_NONE; |
| resume_all_vcpus(); |
| qapi_event_send_wakeup(); |
| } |
| if (qemu_powerdown_requested()) { |
| qemu_system_powerdown(); |
| } |
| if (qemu_vmstop_requested(&r)) { |
| vm_stop(r); |
| } |
| return false; |
| } |
| |
| void qemu_main_loop(void) |
| { |
| #ifdef CONFIG_PROFILER |
| int64_t ti; |
| #endif |
| while (!main_loop_should_exit()) { |
| #ifdef CONFIG_PROFILER |
| ti = profile_getclock(); |
| #endif |
| main_loop_wait(false); |
| #ifdef CONFIG_PROFILER |
| dev_time += profile_getclock() - ti; |
| #endif |
| } |
| } |
| |
| void qemu_add_exit_notifier(Notifier *notify) |
| { |
| notifier_list_add(&exit_notifiers, notify); |
| } |
| |
| void qemu_remove_exit_notifier(Notifier *notify) |
| { |
| notifier_remove(notify); |
| } |
| |
| static void qemu_run_exit_notifiers(void) |
| { |
| notifier_list_notify(&exit_notifiers, NULL); |
| } |
| |
| void qemu_init_subsystems(void) |
| { |
| Error *err; |
| |
| os_set_line_buffering(); |
| |
| module_call_init(MODULE_INIT_TRACE); |
| |
| qemu_init_cpu_list(); |
| qemu_init_cpu_loop(); |
| qemu_mutex_lock_iothread(); |
| |
| atexit(qemu_run_exit_notifiers); |
| |
| module_call_init(MODULE_INIT_QOM); |
| module_call_init(MODULE_INIT_MIGRATION); |
| |
| runstate_init(); |
| precopy_infrastructure_init(); |
| postcopy_infrastructure_init(); |
| monitor_init_globals(); |
| |
| if (qcrypto_init(&err) < 0) { |
| error_reportf_err(err, "cannot initialize crypto: "); |
| exit(1); |
| } |
| |
| os_setup_early_signal_handling(); |
| |
| bdrv_init_with_whitelist(); |
| socket_init(); |
| } |
| |
| |
| void qemu_cleanup(void) |
| { |
| gdb_exit(0); |
| |
| /* |
| * cleaning up the migration object cancels any existing migration |
| * try to do this early so that it also stops using devices. |
| */ |
| migration_shutdown(); |
| |
| /* |
| * Close the exports before draining the block layer. The export |
| * drivers may have coroutines yielding on it, so we need to clean |
| * them up before the drain, as otherwise they may be get stuck in |
| * blk_wait_while_drained(). |
| */ |
| blk_exp_close_all(); |
| |
| /* |
| * We must cancel all block jobs while the block layer is drained, |
| * or cancelling will be affected by throttling and thus may block |
| * for an extended period of time. |
| * vm_shutdown() will bdrv_drain_all(), so we may as well include |
| * it in the drained section. |
| * We do not need to end this section, because we do not want any |
| * requests happening from here on anyway. |
| */ |
| bdrv_drain_all_begin(); |
| |
| /* No more vcpu or device emulation activity beyond this point */ |
| vm_shutdown(); |
| replay_finish(); |
| |
| job_cancel_sync_all(); |
| bdrv_close_all(); |
| |
| /* vhost-user must be cleaned up before chardevs. */ |
| tpm_cleanup(); |
| net_cleanup(); |
| audio_cleanup(); |
| monitor_cleanup(); |
| qemu_chr_cleanup(); |
| user_creatable_cleanup(); |
| /* TODO: unref root container, check all devices are ok */ |
| } |