/* vl.c */
typedef enum {
- RSTATE_DEBUG, /* qemu is running under gdb */
- RSTATE_IN_MIGRATE, /* paused waiting for an incoming migration */
- RSTATE_PANICKED, /* paused due to an internal error */
- RSTATE_IO_ERROR, /* paused due to an I/O error */
- RSTATE_PAUSED, /* paused by the user (ie. the 'stop' command) */
- RSTATE_POST_MIGRATE, /* paused following a successful migration */
- RSTATE_PRE_LAUNCH, /* qemu was started with -S and haven't started */
- RSTATE_PRE_MIGRATE, /* paused preparing to finish migrate */
- RSTATE_RESTORE, /* paused restoring the VM state */
- RSTATE_RUNNING, /* qemu is running */
- RSTATE_SAVEVM, /* paused saving VM state */
- RSTATE_SHUTDOWN, /* guest shut down and -no-shutdown is in use */
- RSTATE_WATCHDOG, /* watchdog fired and qemu is configured to pause */
- RSTATE_MAX
+ RUN_STATE_DEBUG, /* qemu is running under gdb */
+ RUN_STATE_INMIGRATE, /* paused waiting for an incoming migration */
+ RUN_STATE_INTERNAL_ERROR, /* paused due to an internal error */
+ RUN_STATE_IO_ERROR, /* paused due to an I/O error */
+ RUN_STATE_PAUSED, /* paused by the user (ie. the 'stop' command) */
+ RUN_STATE_POSTMIGRATE, /* paused following a successful migration */
+ RUN_STATE_PRELAUNCH, /* qemu was started with -S and haven't started */
+ RUN_STATE_FINISH_MIGRATE, /* paused preparing to finish migrate */
+ RUN_STATE_RESTORE_VM, /* paused restoring the VM state */
+ RUN_STATE_RUNNING, /* qemu is running */
+ RUN_STATE_SAVE_VM, /* paused saving VM state */
+ RUN_STATE_SHUTDOWN, /* guest shut down and -no-shutdown is in use */
+ RUN_STATE_WATCHDOG, /* watchdog fired and qemu is configured to pause */
+ RUN_STATE_MAX
} RunState;
extern const char *bios_name;
/***********************************************************/
/* QEMU state */
-static RunState current_run_state = RSTATE_PRE_LAUNCH;
+static RunState current_run_state = RUN_STATE_PRELAUNCH;
typedef struct {
RunState from;
static const RunStateTransition runstate_transitions_def[] = {
/* from -> to */
- { RSTATE_DEBUG, RSTATE_RUNNING },
+ { RUN_STATE_DEBUG, RUN_STATE_RUNNING },
- { RSTATE_IN_MIGRATE, RSTATE_RUNNING },
- { RSTATE_IN_MIGRATE, RSTATE_PRE_LAUNCH },
+ { RUN_STATE_INMIGRATE, RUN_STATE_RUNNING },
+ { RUN_STATE_INMIGRATE, RUN_STATE_PRELAUNCH },
- { RSTATE_PANICKED, RSTATE_PAUSED },
+ { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PAUSED },
- { RSTATE_IO_ERROR, RSTATE_RUNNING },
+ { RUN_STATE_IO_ERROR, RUN_STATE_RUNNING },
- { RSTATE_PAUSED, RSTATE_RUNNING },
+ { RUN_STATE_PAUSED, RUN_STATE_RUNNING },
- { RSTATE_POST_MIGRATE, RSTATE_RUNNING },
+ { RUN_STATE_POSTMIGRATE, RUN_STATE_RUNNING },
- { RSTATE_PRE_LAUNCH, RSTATE_RUNNING },
- { RSTATE_PRE_LAUNCH, RSTATE_IN_MIGRATE },
- { RSTATE_PRE_LAUNCH, RSTATE_POST_MIGRATE },
+ { RUN_STATE_PRELAUNCH, RUN_STATE_RUNNING },
+ { RUN_STATE_PRELAUNCH, RUN_STATE_INMIGRATE },
+ { RUN_STATE_PRELAUNCH, RUN_STATE_POSTMIGRATE },
- { RSTATE_PRE_MIGRATE, RSTATE_RUNNING },
- { RSTATE_PRE_MIGRATE, RSTATE_POST_MIGRATE },
+ { RUN_STATE_FINISH_MIGRATE, RUN_STATE_RUNNING },
+ { RUN_STATE_FINISH_MIGRATE, RUN_STATE_POSTMIGRATE },
- { RSTATE_RESTORE, RSTATE_RUNNING },
+ { RUN_STATE_RESTORE_VM, RUN_STATE_RUNNING },
- { RSTATE_RUNNING, RSTATE_DEBUG },
- { RSTATE_RUNNING, RSTATE_PANICKED },
- { RSTATE_RUNNING, RSTATE_IO_ERROR },
- { RSTATE_RUNNING, RSTATE_PAUSED },
- { RSTATE_RUNNING, RSTATE_PRE_MIGRATE },
- { RSTATE_RUNNING, RSTATE_RESTORE },
- { RSTATE_RUNNING, RSTATE_SAVEVM },
- { RSTATE_RUNNING, RSTATE_SHUTDOWN },
- { RSTATE_RUNNING, RSTATE_WATCHDOG },
+ { 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 },
- { RSTATE_SAVEVM, RSTATE_RUNNING },
+ { RUN_STATE_SAVE_VM, RUN_STATE_RUNNING },
- { RSTATE_SHUTDOWN, RSTATE_PAUSED },
+ { RUN_STATE_SHUTDOWN, RUN_STATE_PAUSED },
- { RSTATE_WATCHDOG, RSTATE_RUNNING },
+ { RUN_STATE_WATCHDOG, RUN_STATE_RUNNING },
- { RSTATE_MAX, RSTATE_MAX },
+ { RUN_STATE_MAX, RUN_STATE_MAX },
};
-static bool runstate_valid_transitions[RSTATE_MAX][RSTATE_MAX];
-
-static const char *const runstate_name_tbl[RSTATE_MAX] = {
- [RSTATE_DEBUG] = "debug",
- [RSTATE_IN_MIGRATE] = "incoming-migration",
- [RSTATE_PANICKED] = "internal-error",
- [RSTATE_IO_ERROR] = "io-error",
- [RSTATE_PAUSED] = "paused",
- [RSTATE_POST_MIGRATE] = "post-migrate",
- [RSTATE_PRE_LAUNCH] = "prelaunch",
- [RSTATE_PRE_MIGRATE] = "finish-migrate",
- [RSTATE_RESTORE] = "restore-vm",
- [RSTATE_RUNNING] = "running",
- [RSTATE_SAVEVM] = "save-vm",
- [RSTATE_SHUTDOWN] = "shutdown",
- [RSTATE_WATCHDOG] = "watchdog",
+static bool runstate_valid_transitions[RUN_STATE_MAX][RUN_STATE_MAX];
+
+static const char *const runstate_name_tbl[RUN_STATE_MAX] = {
+ [RUN_STATE_DEBUG] = "debug",
+ [RUN_STATE_INMIGRATE] = "incoming-migration",
+ [RUN_STATE_INTERNAL_ERROR] = "internal-error",
+ [RUN_STATE_IO_ERROR] = "io-error",
+ [RUN_STATE_PAUSED] = "paused",
+ [RUN_STATE_POSTMIGRATE] = "post-migrate",
+ [RUN_STATE_PRELAUNCH] = "prelaunch",
+ [RUN_STATE_FINISH_MIGRATE] = "finish-migrate",
+ [RUN_STATE_RESTORE_VM] = "restore-vm",
+ [RUN_STATE_RUNNING] = "running",
+ [RUN_STATE_SAVE_VM] = "save-vm",
+ [RUN_STATE_SHUTDOWN] = "shutdown",
+ [RUN_STATE_WATCHDOG] = "watchdog",
};
bool runstate_check(RunState state)
memset(&runstate_valid_transitions, 0, sizeof(runstate_valid_transitions));
- for (p = &runstate_transitions_def[0]; p->from != RSTATE_MAX; p++) {
+ for (p = &runstate_transitions_def[0]; p->from != RUN_STATE_MAX; p++) {
runstate_valid_transitions[p->from][p->to] = true;
}
}
/* This function will abort() on invalid state transitions */
void runstate_set(RunState new_state)
{
- if (new_state >= RSTATE_MAX ||
+ if (new_state >= RUN_STATE_MAX ||
!runstate_valid_transitions[current_run_state][new_state]) {
fprintf(stderr, "invalid runstate transition\n");
abort();
const char *runstate_as_string(void)
{
- assert(current_run_state < RSTATE_MAX);
+ assert(current_run_state < RUN_STATE_MAX);
return runstate_name_tbl[current_run_state];
}
int runstate_is_running(void)
{
- return runstate_check(RSTATE_RUNNING);
+ return runstate_check(RUN_STATE_RUNNING);
}
/***********************************************************/
{
if (!runstate_is_running()) {
cpu_enable_ticks();
- runstate_set(RSTATE_RUNNING);
- vm_state_notify(1, RSTATE_RUNNING);
+ runstate_set(RUN_STATE_RUNNING);
+ vm_state_notify(1, RUN_STATE_RUNNING);
resume_all_vcpus();
monitor_protocol_event(QEVENT_RESUME, NULL);
}
static pid_t shutdown_pid;
static int powerdown_requested;
static int debug_requested;
-static RunState vmstop_requested = RSTATE_MAX;
+static RunState vmstop_requested = RUN_STATE_MAX;
int qemu_shutdown_requested_get(void)
{
return r;
}
-/* We use RSTATE_MAX but any invalid value will do */
+/* We use RUN_STATE_MAX but any invalid value will do */
static bool qemu_vmstop_requested(RunState *r)
{
- if (vmstop_requested < RSTATE_MAX) {
+ if (vmstop_requested < RUN_STATE_MAX) {
*r = vmstop_requested;
- vmstop_requested = RSTATE_MAX;
+ vmstop_requested = RUN_STATE_MAX;
return true;
}
#endif
if (qemu_debug_requested()) {
- vm_stop(RSTATE_DEBUG);
+ vm_stop(RUN_STATE_DEBUG);
}
if (qemu_shutdown_requested()) {
qemu_kill_report();
monitor_protocol_event(QEVENT_SHUTDOWN, NULL);
if (no_shutdown) {
- vm_stop(RSTATE_SHUTDOWN);
+ vm_stop(RUN_STATE_SHUTDOWN);
} else
break;
}
cpu_synchronize_all_states();
qemu_system_reset(VMRESET_REPORT);
resume_all_vcpus();
- if (runstate_check(RSTATE_PANICKED) ||
- runstate_check(RSTATE_SHUTDOWN)) {
- runstate_set(RSTATE_PAUSED);
+ if (runstate_check(RUN_STATE_INTERNAL_ERROR) ||
+ runstate_check(RUN_STATE_SHUTDOWN)) {
+ runstate_set(RUN_STATE_PAUSED);
}
}
if (qemu_powerdown_requested()) {
}
if (incoming) {
- runstate_set(RSTATE_IN_MIGRATE);
+ runstate_set(RUN_STATE_INMIGRATE);
int ret = qemu_start_incoming_migration(incoming);
if (ret < 0) {
fprintf(stderr, "Migration failed. Exit code %s(%d), exiting.\n",