| Message ID | 20201123141435.2726558-33-pbonzini@redhat.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | cleanup qemu_init and make sense of command line processing | expand |
On Mon, 23 Nov 2020 09:14:31 -0500 Paolo Bonzini <pbonzini@redhat.com> wrote: > Signed-off-by: Paolo Bonzini <pbonzini@redhat.com> Looks like a lot more than just runstate, starting from qemu_init_subsystems() which pulls in a lot of headers. But I don't have a better idea how to name new file, maybe latter it could be split further, but for now Acked-by: Igor Mammedov <imammedo@redhat.com> > --- > include/sysemu/sysemu.h | 3 + > softmmu/meson.build | 1 + > softmmu/runstate.c | 800 ++++++++++++++++++++++++++++++++++++++++ > softmmu/vl.c | 752 +------------------------------------ > 4 files changed, 805 insertions(+), 751 deletions(-) > create mode 100644 softmmu/runstate.c > > diff --git a/include/sysemu/sysemu.h b/include/sysemu/sysemu.h > index 18cf586cd0..3dac3229ec 100644 > --- a/include/sysemu/sysemu.h > +++ b/include/sysemu/sysemu.h > @@ -24,6 +24,8 @@ void qemu_remove_machine_init_done_notifier(Notifier *notify); > > void configure_rtc(QemuOpts *opts); > > +void qemu_init_subsystems(void); > + > extern int autostart; > > typedef enum { > @@ -44,6 +46,7 @@ extern int alt_grab; > extern int ctrl_grab; > extern int graphic_rotate; > extern int no_shutdown; > +extern int no_reboot; > extern int old_param; > extern int boot_menu; > extern bool boot_strict; > diff --git a/softmmu/meson.build b/softmmu/meson.build > index d098d89653..2a73ebc223 100644 > --- a/softmmu/meson.build > +++ b/softmmu/meson.build > @@ -7,6 +7,7 @@ specific_ss.add(when: 'CONFIG_SOFTMMU', if_true: [files( > 'physmem.c', > 'ioport.c', > 'rtc.c', > + 'runstate.c', > 'memory.c', > 'memory_mapping.c', > 'qtest.c', > diff --git a/softmmu/runstate.c b/softmmu/runstate.c > new file mode 100644 > index 0000000000..892f2f679f > --- /dev/null > +++ b/softmmu/runstate.c > @@ -0,0 +1,800 @@ > +/* > + * 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 "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/sysemu.h" > +#include "sysemu/tpm.h" > +#include "trace.h" looks like an awful lot headers just for runstate > + > +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_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; > +} > + > +int 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(int 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; > + } > + qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_PAUSE, > + !!info, info); > + vm_stop(RUN_STATE_GUEST_PANICKED); > + if (!no_shutdown) { > + qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_POWEROFF, > + !!info, info); > + qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_PANIC); > + } > + > + 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 (no_reboot && reason != SHUTDOWN_CAUSE_SUBSYSTEM_RESET) { > + 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; > + no_shutdown = 0; > + > + /* 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 (no_shutdown) { > + 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) > +{ > + gdbserver_cleanup(); > + > + /* > + * cleaning up the migration object cancels any existing migration > + * try to do this early so that it also stops using devices. > + */ > + migration_shutdown(); > + > + /* > + * 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 */ > +} > diff --git a/softmmu/vl.c b/softmmu/vl.c > index c9bb205c42..914b86ee86 100644 > --- a/softmmu/vl.c > +++ b/softmmu/vl.c > @@ -112,7 +112,6 @@ > #include "qapi/qapi-commands-block-core.h" > #include "qapi/qapi-commands-migration.h" > #include "qapi/qapi-commands-misc.h" > -#include "qapi/qapi-commands-run-state.h" > #include "qapi/qapi-commands-ui.h" > #include "qapi/qmp/qerror.h" > #include "sysemu/iothread.h" > @@ -164,7 +163,7 @@ Chardev *parallel_hds[MAX_PARALLEL_PORTS]; > int win2k_install_hack = 0; > int singlestep = 0; > int fd_bootchk = 1; > -static int no_reboot; > +int no_reboot; > int no_shutdown = 0; > int graphic_rotate = 0; > static const char *watchdog; > @@ -191,9 +190,6 @@ static const char *qtest_log; > QemuUUID qemu_uuid; > bool qemu_uuid_set; > > -static NotifierList exit_notifiers = > - NOTIFIER_LIST_INITIALIZER(exit_notifiers); > - > uint32_t xen_domid; > enum xen_mode xen_mode = XEN_EMULATE; > bool xen_domid_restrict; > @@ -535,12 +531,6 @@ const char *qemu_get_vm_name(void) > return qemu_name; > } > > -static void res_free(void) > -{ > - g_free(boot_splash_filedata); > - boot_splash_filedata = NULL; > -} > - > static int default_driver_check(void *opaque, QemuOpts *opts, Error **errp) > { > const char *driver = qemu_opt_get(opts, "driver"); > @@ -556,206 +546,6 @@ static int default_driver_check(void *opaque, QemuOpts *opts, Error **errp) > return 0; > } > > -/***********************************************************/ > -/* QEMU state */ > - > -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_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; > -} > - > -int 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(); > -} > static int parse_name(void *opaque, QemuOpts *opts, Error **errp) > { > const char *proc_name; > @@ -1072,458 +862,6 @@ static int machine_help_func(QemuOpts *opts, MachineState *machine) > return 1; > } > > -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(int 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; > - } > - qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_PAUSE, > - !!info, info); > - vm_stop(RUN_STATE_GUEST_PANICKED); > - if (!no_shutdown) { > - qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_POWEROFF, > - !!info, info); > - qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_PANIC); > - } > - > - 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 (no_reboot && reason != SHUTDOWN_CAUSE_SUBSYSTEM_RESET) { > - 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); > -} > - > -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; > - no_shutdown = 0; > - > - /* 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 (no_shutdown) { > - 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 > - } > -} > - > static void version(void) > { > printf("QEMU emulator version " QEMU_FULL_VERSION "\n" > @@ -2248,21 +1586,6 @@ static MachineClass *machine_parse(const char *name, GSList *machines) > return mc; > } > > -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); > -} > - > static const char *pid_file; > static Notifier qemu_unlink_pidfile_notifier; > > @@ -3061,39 +2384,6 @@ static void qemu_maybe_daemonize(const char *pid_file) > qemu_add_exit_notifier(&qemu_unlink_pidfile_notifier); > } > > -static 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(); > -} > - > static void qemu_init_displays(void) > { > DisplayState *ds; > @@ -4275,43 +3565,3 @@ void qemu_init(int argc, char **argv, char **envp) > accel_setup_post(current_machine); > os_setup_post(); > } > - > -void qemu_cleanup(void) > -{ > - gdbserver_cleanup(); > - > - /* > - * cleaning up the migration object cancels any existing migration > - * try to do this early so that it also stops using devices. > - */ > - migration_shutdown(); > - > - /* > - * 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(); > - > - res_free(); > - > - /* 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 */ > -}
diff --git a/include/sysemu/sysemu.h b/include/sysemu/sysemu.h index 18cf586cd0..3dac3229ec 100644 --- a/include/sysemu/sysemu.h +++ b/include/sysemu/sysemu.h @@ -24,6 +24,8 @@ void qemu_remove_machine_init_done_notifier(Notifier *notify); void configure_rtc(QemuOpts *opts); +void qemu_init_subsystems(void); + extern int autostart; typedef enum { @@ -44,6 +46,7 @@ extern int alt_grab; extern int ctrl_grab; extern int graphic_rotate; extern int no_shutdown; +extern int no_reboot; extern int old_param; extern int boot_menu; extern bool boot_strict; diff --git a/softmmu/meson.build b/softmmu/meson.build index d098d89653..2a73ebc223 100644 --- a/softmmu/meson.build +++ b/softmmu/meson.build @@ -7,6 +7,7 @@ specific_ss.add(when: 'CONFIG_SOFTMMU', if_true: [files( 'physmem.c', 'ioport.c', 'rtc.c', + 'runstate.c', 'memory.c', 'memory_mapping.c', 'qtest.c', diff --git a/softmmu/runstate.c b/softmmu/runstate.c new file mode 100644 index 0000000000..892f2f679f --- /dev/null +++ b/softmmu/runstate.c @@ -0,0 +1,800 @@ +/* + * 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 "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/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_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; +} + +int 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(int 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; + } + qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_PAUSE, + !!info, info); + vm_stop(RUN_STATE_GUEST_PANICKED); + if (!no_shutdown) { + qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_POWEROFF, + !!info, info); + qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_PANIC); + } + + 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 (no_reboot && reason != SHUTDOWN_CAUSE_SUBSYSTEM_RESET) { + 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; + no_shutdown = 0; + + /* 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 (no_shutdown) { + 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) +{ + gdbserver_cleanup(); + + /* + * cleaning up the migration object cancels any existing migration + * try to do this early so that it also stops using devices. + */ + migration_shutdown(); + + /* + * 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 */ +} diff --git a/softmmu/vl.c b/softmmu/vl.c index c9bb205c42..914b86ee86 100644 --- a/softmmu/vl.c +++ b/softmmu/vl.c @@ -112,7 +112,6 @@ #include "qapi/qapi-commands-block-core.h" #include "qapi/qapi-commands-migration.h" #include "qapi/qapi-commands-misc.h" -#include "qapi/qapi-commands-run-state.h" #include "qapi/qapi-commands-ui.h" #include "qapi/qmp/qerror.h" #include "sysemu/iothread.h" @@ -164,7 +163,7 @@ Chardev *parallel_hds[MAX_PARALLEL_PORTS]; int win2k_install_hack = 0; int singlestep = 0; int fd_bootchk = 1; -static int no_reboot; +int no_reboot; int no_shutdown = 0; int graphic_rotate = 0; static const char *watchdog; @@ -191,9 +190,6 @@ static const char *qtest_log; QemuUUID qemu_uuid; bool qemu_uuid_set; -static NotifierList exit_notifiers = - NOTIFIER_LIST_INITIALIZER(exit_notifiers); - uint32_t xen_domid; enum xen_mode xen_mode = XEN_EMULATE; bool xen_domid_restrict; @@ -535,12 +531,6 @@ const char *qemu_get_vm_name(void) return qemu_name; } -static void res_free(void) -{ - g_free(boot_splash_filedata); - boot_splash_filedata = NULL; -} - static int default_driver_check(void *opaque, QemuOpts *opts, Error **errp) { const char *driver = qemu_opt_get(opts, "driver"); @@ -556,206 +546,6 @@ static int default_driver_check(void *opaque, QemuOpts *opts, Error **errp) return 0; } -/***********************************************************/ -/* QEMU state */ - -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_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; -} - -int 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(); -} static int parse_name(void *opaque, QemuOpts *opts, Error **errp) { const char *proc_name; @@ -1072,458 +862,6 @@ static int machine_help_func(QemuOpts *opts, MachineState *machine) return 1; } -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(int 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; - } - qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_PAUSE, - !!info, info); - vm_stop(RUN_STATE_GUEST_PANICKED); - if (!no_shutdown) { - qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_POWEROFF, - !!info, info); - qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_PANIC); - } - - 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 (no_reboot && reason != SHUTDOWN_CAUSE_SUBSYSTEM_RESET) { - 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); -} - -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; - no_shutdown = 0; - - /* 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 (no_shutdown) { - 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 - } -} - static void version(void) { printf("QEMU emulator version " QEMU_FULL_VERSION "\n" @@ -2248,21 +1586,6 @@ static MachineClass *machine_parse(const char *name, GSList *machines) return mc; } -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); -} - static const char *pid_file; static Notifier qemu_unlink_pidfile_notifier; @@ -3061,39 +2384,6 @@ static void qemu_maybe_daemonize(const char *pid_file) qemu_add_exit_notifier(&qemu_unlink_pidfile_notifier); } -static 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(); -} - static void qemu_init_displays(void) { DisplayState *ds; @@ -4275,43 +3565,3 @@ void qemu_init(int argc, char **argv, char **envp) accel_setup_post(current_machine); os_setup_post(); } - -void qemu_cleanup(void) -{ - gdbserver_cleanup(); - - /* - * cleaning up the migration object cancels any existing migration - * try to do this early so that it also stops using devices. - */ - migration_shutdown(); - - /* - * 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(); - - res_free(); - - /* 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 */ -}
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com> --- include/sysemu/sysemu.h | 3 + softmmu/meson.build | 1 + softmmu/runstate.c | 800 ++++++++++++++++++++++++++++++++++++++++ softmmu/vl.c | 752 +------------------------------------ 4 files changed, 805 insertions(+), 751 deletions(-) create mode 100644 softmmu/runstate.c