system/runstate.c

   1 /*
   2  * QEMU main system emulation loop
   3  *
   4  * Copyright (c) 2003-2020 QEMU contributors
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 #include "qemu/osdep.h"
  26 #include "audio/audio.h"
  27 #include "block/block.h"
  28 #include "block/export.h"
  29 #include "chardev/char.h"
  30 #include "crypto/cipher.h"
  31 #include "crypto/init.h"
  32 #include "exec/cpu-common.h"
  33 #include "gdbstub/syscalls.h"
  34 #include "hw/boards.h"
  35 #include "migration/misc.h"
  36 #include "migration/postcopy-ram.h"
  37 #include "monitor/monitor.h"
  38 #include "net/net.h"
  39 #include "net/vhost_net.h"
  40 #include "qapi/error.h"
  41 #include "qapi/qapi-commands-run-state.h"
  42 #include "qapi/qapi-events-run-state.h"
  43 #include "qemu/accel.h"
  44 #include "qemu/error-report.h"
  45 #include "qemu/job.h"
  46 #include "qemu/log.h"
  47 #include "qemu/module.h"
  48 #include "qemu/sockets.h"
  49 #include "qemu/timer.h"
  50 #include "qemu/thread.h"
  51 #include "qom/object.h"
  52 #include "qom/object_interfaces.h"
  53 #include "sysemu/cpus.h"
  54 #include "sysemu/qtest.h"
  55 #include "sysemu/replay.h"
  56 #include "sysemu/reset.h"
  57 #include "sysemu/runstate.h"
  58 #include "sysemu/runstate-action.h"
  59 #include "sysemu/sysemu.h"
  60 #include "sysemu/tpm.h"
  61 #include "trace.h"
  62
  63 static NotifierList exit_notifiers =
  64     NOTIFIER_LIST_INITIALIZER(exit_notifiers);
  65
  66 static RunState current_run_state = RUN_STATE_PRELAUNCH;
  67
  68 /* We use RUN_STATE__MAX but any invalid value will do */
  69 static RunState vmstop_requested = RUN_STATE__MAX;
  70 static QemuMutex vmstop_lock;
  71
  72 typedef struct {
  73     RunState from;
  74     RunState to;
  75 } RunStateTransition;
  76
  77 static const RunStateTransition runstate_transitions_def[] = {
  78     { RUN_STATE_PRELAUNCH, RUN_STATE_INMIGRATE },
  79     { RUN_STATE_PRELAUNCH, RUN_STATE_SUSPENDED },
  80
  81     { RUN_STATE_DEBUG, RUN_STATE_RUNNING },
  82     { RUN_STATE_DEBUG, RUN_STATE_FINISH_MIGRATE },
  83     { RUN_STATE_DEBUG, RUN_STATE_PRELAUNCH },
  84
  85     { RUN_STATE_INMIGRATE, RUN_STATE_INTERNAL_ERROR },
  86     { RUN_STATE_INMIGRATE, RUN_STATE_IO_ERROR },
  87     { RUN_STATE_INMIGRATE, RUN_STATE_PAUSED },
  88     { RUN_STATE_INMIGRATE, RUN_STATE_RUNNING },
  89     { RUN_STATE_INMIGRATE, RUN_STATE_SHUTDOWN },
  90     { RUN_STATE_INMIGRATE, RUN_STATE_SUSPENDED },
  91     { RUN_STATE_INMIGRATE, RUN_STATE_WATCHDOG },
  92     { RUN_STATE_INMIGRATE, RUN_STATE_GUEST_PANICKED },
  93     { RUN_STATE_INMIGRATE, RUN_STATE_FINISH_MIGRATE },
  94     { RUN_STATE_INMIGRATE, RUN_STATE_PRELAUNCH },
  95     { RUN_STATE_INMIGRATE, RUN_STATE_POSTMIGRATE },
  96     { RUN_STATE_INMIGRATE, RUN_STATE_COLO },
  97
  98     { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PAUSED },
  99     { RUN_STATE_INTERNAL_ERROR, RUN_STATE_FINISH_MIGRATE },
 100     { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PRELAUNCH },
 101
 102     { RUN_STATE_IO_ERROR, RUN_STATE_RUNNING },
 103     { RUN_STATE_IO_ERROR, RUN_STATE_FINISH_MIGRATE },
 104     { RUN_STATE_IO_ERROR, RUN_STATE_PRELAUNCH },
 105
 106     { RUN_STATE_PAUSED, RUN_STATE_RUNNING },
 107     { RUN_STATE_PAUSED, RUN_STATE_FINISH_MIGRATE },
 108     { RUN_STATE_PAUSED, RUN_STATE_POSTMIGRATE },
 109     { RUN_STATE_PAUSED, RUN_STATE_PRELAUNCH },
 110     { RUN_STATE_PAUSED, RUN_STATE_COLO},
 111     { RUN_STATE_PAUSED, RUN_STATE_SUSPENDED},
 112
 113     { RUN_STATE_POSTMIGRATE, RUN_STATE_RUNNING },
 114     { RUN_STATE_POSTMIGRATE, RUN_STATE_FINISH_MIGRATE },
 115     { RUN_STATE_POSTMIGRATE, RUN_STATE_PRELAUNCH },
 116
 117     { RUN_STATE_PRELAUNCH, RUN_STATE_RUNNING },
 118     { RUN_STATE_PRELAUNCH, RUN_STATE_FINISH_MIGRATE },
 119     { RUN_STATE_PRELAUNCH, RUN_STATE_INMIGRATE },
 120
 121     { RUN_STATE_FINISH_MIGRATE, RUN_STATE_RUNNING },
 122     { RUN_STATE_FINISH_MIGRATE, RUN_STATE_PAUSED },
 123     { RUN_STATE_FINISH_MIGRATE, RUN_STATE_POSTMIGRATE },
 124     { RUN_STATE_FINISH_MIGRATE, RUN_STATE_PRELAUNCH },
 125     { RUN_STATE_FINISH_MIGRATE, RUN_STATE_COLO },
 126     { RUN_STATE_FINISH_MIGRATE, RUN_STATE_INTERNAL_ERROR },
 127     { RUN_STATE_FINISH_MIGRATE, RUN_STATE_IO_ERROR },
 128     { RUN_STATE_FINISH_MIGRATE, RUN_STATE_SHUTDOWN },
 129     { RUN_STATE_FINISH_MIGRATE, RUN_STATE_SUSPENDED },
 130     { RUN_STATE_FINISH_MIGRATE, RUN_STATE_WATCHDOG },
 131     { RUN_STATE_FINISH_MIGRATE, RUN_STATE_GUEST_PANICKED },
 132
 133     { RUN_STATE_RESTORE_VM, RUN_STATE_RUNNING },
 134     { RUN_STATE_RESTORE_VM, RUN_STATE_PRELAUNCH },
 135     { RUN_STATE_RESTORE_VM, RUN_STATE_SUSPENDED },
 136
 137     { RUN_STATE_COLO, RUN_STATE_RUNNING },
 138     { RUN_STATE_COLO, RUN_STATE_PRELAUNCH },
 139     { RUN_STATE_COLO, RUN_STATE_SHUTDOWN},
 140
 141     { RUN_STATE_RUNNING, RUN_STATE_DEBUG },
 142     { RUN_STATE_RUNNING, RUN_STATE_INTERNAL_ERROR },
 143     { RUN_STATE_RUNNING, RUN_STATE_IO_ERROR },
 144     { RUN_STATE_RUNNING, RUN_STATE_PAUSED },
 145     { RUN_STATE_RUNNING, RUN_STATE_FINISH_MIGRATE },
 146     { RUN_STATE_RUNNING, RUN_STATE_RESTORE_VM },
 147     { RUN_STATE_RUNNING, RUN_STATE_SAVE_VM },
 148     { RUN_STATE_RUNNING, RUN_STATE_SHUTDOWN },
 149     { RUN_STATE_RUNNING, RUN_STATE_WATCHDOG },
 150     { RUN_STATE_RUNNING, RUN_STATE_GUEST_PANICKED },
 151     { RUN_STATE_RUNNING, RUN_STATE_COLO},
 152
 153     { RUN_STATE_SAVE_VM, RUN_STATE_RUNNING },
 154     { RUN_STATE_SAVE_VM, RUN_STATE_SUSPENDED },
 155
 156     { RUN_STATE_SHUTDOWN, RUN_STATE_PAUSED },
 157     { RUN_STATE_SHUTDOWN, RUN_STATE_FINISH_MIGRATE },
 158     { RUN_STATE_SHUTDOWN, RUN_STATE_PRELAUNCH },
 159     { RUN_STATE_SHUTDOWN, RUN_STATE_COLO },
 160
 161     { RUN_STATE_DEBUG, RUN_STATE_SUSPENDED },
 162     { RUN_STATE_RUNNING, RUN_STATE_SUSPENDED },
 163     { RUN_STATE_SUSPENDED, RUN_STATE_RUNNING },
 164     { RUN_STATE_SUSPENDED, RUN_STATE_FINISH_MIGRATE },
 165     { RUN_STATE_SUSPENDED, RUN_STATE_PRELAUNCH },
 166     { RUN_STATE_SUSPENDED, RUN_STATE_COLO},
 167     { RUN_STATE_SUSPENDED, RUN_STATE_PAUSED},
 168     { RUN_STATE_SUSPENDED, RUN_STATE_SAVE_VM },
 169     { RUN_STATE_SUSPENDED, RUN_STATE_RESTORE_VM },
 170     { RUN_STATE_SUSPENDED, RUN_STATE_SHUTDOWN },
 171
 172     { RUN_STATE_WATCHDOG, RUN_STATE_RUNNING },
 173     { RUN_STATE_WATCHDOG, RUN_STATE_FINISH_MIGRATE },
 174     { RUN_STATE_WATCHDOG, RUN_STATE_PRELAUNCH },
 175     { RUN_STATE_WATCHDOG, RUN_STATE_COLO},
 176
 177     { RUN_STATE_GUEST_PANICKED, RUN_STATE_RUNNING },
 178     { RUN_STATE_GUEST_PANICKED, RUN_STATE_FINISH_MIGRATE },
 179     { RUN_STATE_GUEST_PANICKED, RUN_STATE_PRELAUNCH },
 180
 181     { RUN_STATE__MAX, RUN_STATE__MAX },
 182 };
 183
 184 static bool runstate_valid_transitions[RUN_STATE__MAX][RUN_STATE__MAX];
 185
 186 bool runstate_check(RunState state)
 187 {
 188     return current_run_state == state;
 189 }
 190
 191 static void runstate_init(void)
 192 {
 193     const RunStateTransition *p;
 194
 195     memset(&runstate_valid_transitions, 0, sizeof(runstate_valid_transitions));
 196     for (p = &runstate_transitions_def[0]; p->from != RUN_STATE__MAX; p++) {
 197         runstate_valid_transitions[p->from][p->to] = true;
 198     }
 199
 200     qemu_mutex_init(&vmstop_lock);
 201 }
 202
 203 /* This function will abort() on invalid state transitions */
 204 void runstate_set(RunState new_state)
 205 {
 206     assert(new_state < RUN_STATE__MAX);
 207
 208     trace_runstate_set(current_run_state, RunState_str(current_run_state),
 209                        new_state, RunState_str(new_state));
 210
 211     if (current_run_state == new_state) {
 212         return;
 213     }
 214
 215     if (!runstate_valid_transitions[current_run_state][new_state]) {
 216         error_report("invalid runstate transition: '%s' -> '%s'",
 217                      RunState_str(current_run_state),
 218                      RunState_str(new_state));
 219         abort();
 220     }
 221
 222     current_run_state = new_state;
 223 }
 224
 225 RunState runstate_get(void)
 226 {
 227     return current_run_state;
 228 }
 229
 230 bool runstate_is_running(void)
 231 {
 232     return runstate_check(RUN_STATE_RUNNING);
 233 }
 234
 235 bool runstate_needs_reset(void)
 236 {
 237     return runstate_check(RUN_STATE_INTERNAL_ERROR) ||
 238         runstate_check(RUN_STATE_SHUTDOWN);
 239 }
 240
 241 StatusInfo *qmp_query_status(Error **errp)
 242 {
 243     StatusInfo *info = g_malloc0(sizeof(*info));
 244
 245     info->running = runstate_is_running();
 246     info->status = current_run_state;
 247
 248     return info;
 249 }
 250
 251 bool qemu_vmstop_requested(RunState *r)
 252 {
 253     qemu_mutex_lock(&vmstop_lock);
 254     *r = vmstop_requested;
 255     vmstop_requested = RUN_STATE__MAX;
 256     qemu_mutex_unlock(&vmstop_lock);
 257     return *r < RUN_STATE__MAX;
 258 }
 259
 260 void qemu_system_vmstop_request_prepare(void)
 261 {
 262     qemu_mutex_lock(&vmstop_lock);
 263 }
 264
 265 void qemu_system_vmstop_request(RunState state)
 266 {
 267     vmstop_requested = state;
 268     qemu_mutex_unlock(&vmstop_lock);
 269     qemu_notify_event();
 270 }
 271 struct VMChangeStateEntry {
 272     VMChangeStateHandler *cb;
 273     VMChangeStateHandler *prepare_cb;
 274     void *opaque;
 275     QTAILQ_ENTRY(VMChangeStateEntry) entries;
 276     int priority;
 277 };
 278
 279 static QTAILQ_HEAD(, VMChangeStateEntry) vm_change_state_head =
 280     QTAILQ_HEAD_INITIALIZER(vm_change_state_head);
 281
 282 /**
 283  * qemu_add_vm_change_state_handler_prio:
 284  * @cb: the callback to invoke
 285  * @opaque: user data passed to the callback
 286  * @priority: low priorities execute first when the vm runs and the reverse is
 287  *            true when the vm stops
 288  *
 289  * Register a callback function that is invoked when the vm starts or stops
 290  * running.
 291  *
 292  * Returns: an entry to be freed using qemu_del_vm_change_state_handler()
 293  */
 294 VMChangeStateEntry *qemu_add_vm_change_state_handler_prio(
 295         VMChangeStateHandler *cb, void *opaque, int priority)
 296 {
 297     return qemu_add_vm_change_state_handler_prio_full(cb, NULL, opaque,
 298                                                       priority);
 299 }
 300
 301 /**
 302  * qemu_add_vm_change_state_handler_prio_full:
 303  * @cb: the main callback to invoke
 304  * @prepare_cb: a callback to invoke before the main callback
 305  * @opaque: user data passed to the callbacks
 306  * @priority: low priorities execute first when the vm runs and the reverse is
 307  *            true when the vm stops
 308  *
 309  * Register a main callback function and an optional prepare callback function
 310  * that are invoked when the vm starts or stops running. The main callback and
 311  * the prepare callback are called in two separate phases: First all prepare
 312  * callbacks are called and only then all main callbacks are called. As its
 313  * name suggests, the prepare callback can be used to do some preparatory work
 314  * before invoking the main callback.
 315  *
 316  * Returns: an entry to be freed using qemu_del_vm_change_state_handler()
 317  */
 318 VMChangeStateEntry *
 319 qemu_add_vm_change_state_handler_prio_full(VMChangeStateHandler *cb,
 320                                            VMChangeStateHandler *prepare_cb,
 321                                            void *opaque, int priority)
 322 {
 323     VMChangeStateEntry *e;
 324     VMChangeStateEntry *other;
 325
 326     e = g_malloc0(sizeof(*e));
 327     e->cb = cb;
 328     e->prepare_cb = prepare_cb;
 329     e->opaque = opaque;
 330     e->priority = priority;
 331
 332     /* Keep list sorted in ascending priority order */
 333     QTAILQ_FOREACH(other, &vm_change_state_head, entries) {
 334         if (priority < other->priority) {
 335             QTAILQ_INSERT_BEFORE(other, e, entries);
 336             return e;
 337         }
 338     }
 339
 340     QTAILQ_INSERT_TAIL(&vm_change_state_head, e, entries);
 341     return e;
 342 }
 343
 344 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
 345                                                      void *opaque)
 346 {
 347     return qemu_add_vm_change_state_handler_prio(cb, opaque, 0);
 348 }
 349
 350 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
 351 {
 352     QTAILQ_REMOVE(&vm_change_state_head, e, entries);
 353     g_free(e);
 354 }
 355
 356 void vm_state_notify(bool running, RunState state)
 357 {
 358     VMChangeStateEntry *e, *next;
 359
 360     trace_vm_state_notify(running, state, RunState_str(state));
 361
 362     if (running) {
 363         QTAILQ_FOREACH_SAFE(e, &vm_change_state_head, entries, next) {
 364             if (e->prepare_cb) {
 365                 e->prepare_cb(e->opaque, running, state);
 366             }
 367         }
 368
 369         QTAILQ_FOREACH_SAFE(e, &vm_change_state_head, entries, next) {
 370             e->cb(e->opaque, running, state);
 371         }
 372     } else {
 373         QTAILQ_FOREACH_REVERSE_SAFE(e, &vm_change_state_head, entries, next) {
 374             if (e->prepare_cb) {
 375                 e->prepare_cb(e->opaque, running, state);
 376             }
 377         }
 378
 379         QTAILQ_FOREACH_REVERSE_SAFE(e, &vm_change_state_head, entries, next) {
 380             e->cb(e->opaque, running, state);
 381         }
 382     }
 383 }
 384
 385 static ShutdownCause reset_requested;
 386 static ShutdownCause shutdown_requested;
 387 static int shutdown_exit_code = EXIT_SUCCESS;
 388 static int shutdown_signal;
 389 static pid_t shutdown_pid;
 390 static int powerdown_requested;
 391 static int debug_requested;
 392 static int suspend_requested;
 393 static WakeupReason wakeup_reason;
 394 static NotifierList powerdown_notifiers =
 395     NOTIFIER_LIST_INITIALIZER(powerdown_notifiers);
 396 static NotifierList suspend_notifiers =
 397     NOTIFIER_LIST_INITIALIZER(suspend_notifiers);
 398 static NotifierList wakeup_notifiers =
 399     NOTIFIER_LIST_INITIALIZER(wakeup_notifiers);
 400 static NotifierList shutdown_notifiers =
 401     NOTIFIER_LIST_INITIALIZER(shutdown_notifiers);
 402 static uint32_t wakeup_reason_mask = ~(1 << QEMU_WAKEUP_REASON_NONE);
 403
 404 ShutdownCause qemu_shutdown_requested_get(void)
 405 {
 406     return shutdown_requested;
 407 }
 408
 409 ShutdownCause qemu_reset_requested_get(void)
 410 {
 411     return reset_requested;
 412 }
 413
 414 static int qemu_shutdown_requested(void)
 415 {
 416     return qatomic_xchg(&shutdown_requested, SHUTDOWN_CAUSE_NONE);
 417 }
 418
 419 static void qemu_kill_report(void)
 420 {
 421     if (!qtest_driver() && shutdown_signal) {
 422         if (shutdown_pid == 0) {
 423             /* This happens for eg ^C at the terminal, so it's worth
 424              * avoiding printing an odd message in that case.
 425              */
 426             error_report("terminating on signal %d", shutdown_signal);
 427         } else {
 428             char *shutdown_cmd = qemu_get_pid_name(shutdown_pid);
 429
 430             error_report("terminating on signal %d from pid " FMT_pid " (%s)",
 431                          shutdown_signal, shutdown_pid,
 432                          shutdown_cmd ? shutdown_cmd : "<unknown process>");
 433             g_free(shutdown_cmd);
 434         }
 435         shutdown_signal = 0;
 436     }
 437 }
 438
 439 static ShutdownCause qemu_reset_requested(void)
 440 {
 441     ShutdownCause r = reset_requested;
 442
 443     if (r && replay_checkpoint(CHECKPOINT_RESET_REQUESTED)) {
 444         reset_requested = SHUTDOWN_CAUSE_NONE;
 445         return r;
 446     }
 447     return SHUTDOWN_CAUSE_NONE;
 448 }
 449
 450 static int qemu_suspend_requested(void)
 451 {
 452     int r = suspend_requested;
 453     if (r && replay_checkpoint(CHECKPOINT_SUSPEND_REQUESTED)) {
 454         suspend_requested = 0;
 455         return r;
 456     }
 457     return false;
 458 }
 459
 460 static WakeupReason qemu_wakeup_requested(void)
 461 {
 462     return wakeup_reason;
 463 }
 464
 465 static int qemu_powerdown_requested(void)
 466 {
 467     int r = powerdown_requested;
 468     powerdown_requested = 0;
 469     return r;
 470 }
 471
 472 static int qemu_debug_requested(void)
 473 {
 474     int r = debug_requested;
 475     debug_requested = 0;
 476     return r;
 477 }
 478
 479 /*
 480  * Reset the VM. Issue an event unless @reason is SHUTDOWN_CAUSE_NONE.
 481  */
 482 void qemu_system_reset(ShutdownCause reason)
 483 {
 484     MachineClass *mc;
 485
 486     mc = current_machine ? MACHINE_GET_CLASS(current_machine) : NULL;
 487
 488     cpu_synchronize_all_states();
 489
 490     if (mc && mc->reset) {
 491         mc->reset(current_machine, reason);
 492     } else {
 493         qemu_devices_reset(reason);
 494     }
 495     switch (reason) {
 496     case SHUTDOWN_CAUSE_NONE:
 497     case SHUTDOWN_CAUSE_SUBSYSTEM_RESET:
 498     case SHUTDOWN_CAUSE_SNAPSHOT_LOAD:
 499         break;
 500     default:
 501         qapi_event_send_reset(shutdown_caused_by_guest(reason), reason);
 502     }
 503
 504     /*
 505      * Some boards use the machine reset callback to point CPUs to the firmware
 506      * entry point.  Assume that this is not the case for boards that support
 507      * non-resettable CPUs (currently used only for confidential guests), in
 508      * which case cpu_synchronize_all_post_init() is enough because
 509      * it does _more_  than cpu_synchronize_all_post_reset().
 510      */
 511     if (cpus_are_resettable()) {
 512         cpu_synchronize_all_post_reset();
 513     } else {
 514         assert(runstate_check(RUN_STATE_PRELAUNCH));
 515     }
 516
 517     vm_set_suspended(false);
 518 }
 519
 520 /*
 521  * Wake the VM after suspend.
 522  */
 523 static void qemu_system_wakeup(void)
 524 {
 525     MachineClass *mc;
 526
 527     mc = current_machine ? MACHINE_GET_CLASS(current_machine) : NULL;
 528
 529     if (mc && mc->wakeup) {
 530         mc->wakeup(current_machine);
 531     }
 532 }
 533
 534 void qemu_system_guest_panicked(GuestPanicInformation *info)
 535 {
 536     qemu_log_mask(LOG_GUEST_ERROR, "Guest crashed");
 537
 538     if (current_cpu) {
 539         current_cpu->crash_occurred = true;
 540     }
 541     /*
 542      * TODO:  Currently the available panic actions are: none, pause, and
 543      * shutdown, but in principle debug and reset could be supported as well.
 544      * Investigate any potential use cases for the unimplemented actions.
 545      */
 546     if (panic_action == PANIC_ACTION_PAUSE
 547         || (panic_action == PANIC_ACTION_SHUTDOWN && shutdown_action == SHUTDOWN_ACTION_PAUSE)) {
 548         qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_PAUSE, info);
 549         vm_stop(RUN_STATE_GUEST_PANICKED);
 550     } else if (panic_action == PANIC_ACTION_SHUTDOWN ||
 551                panic_action == PANIC_ACTION_EXIT_FAILURE) {
 552         qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_POWEROFF, info);
 553         vm_stop(RUN_STATE_GUEST_PANICKED);
 554         qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_PANIC);
 555     } else {
 556         qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_RUN, info);
 557     }
 558
 559     if (info) {
 560         if (info->type == GUEST_PANIC_INFORMATION_TYPE_HYPER_V) {
 561             qemu_log_mask(LOG_GUEST_ERROR, "\nHV crash parameters: (%#"PRIx64
 562                           " %#"PRIx64" %#"PRIx64" %#"PRIx64" %#"PRIx64")\n",
 563                           info->u.hyper_v.arg1,
 564                           info->u.hyper_v.arg2,
 565                           info->u.hyper_v.arg3,
 566                           info->u.hyper_v.arg4,
 567                           info->u.hyper_v.arg5);
 568         } else if (info->type == GUEST_PANIC_INFORMATION_TYPE_S390) {
 569             qemu_log_mask(LOG_GUEST_ERROR, " on cpu %d: %s\n"
 570                           "PSW: 0x%016" PRIx64 " 0x%016" PRIx64"\n",
 571                           info->u.s390.core,
 572                           S390CrashReason_str(info->u.s390.reason),
 573                           info->u.s390.psw_mask,
 574                           info->u.s390.psw_addr);
 575         }
 576         qapi_free_GuestPanicInformation(info);
 577     }
 578 }
 579
 580 void qemu_system_guest_crashloaded(GuestPanicInformation *info)
 581 {
 582     qemu_log_mask(LOG_GUEST_ERROR, "Guest crash loaded");
 583     qapi_event_send_guest_crashloaded(GUEST_PANIC_ACTION_RUN, info);
 584     qapi_free_GuestPanicInformation(info);
 585 }
 586
 587 void qemu_system_guest_pvshutdown(void)
 588 {
 589     qapi_event_send_guest_pvshutdown();
 590     qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN);
 591 }
 592
 593 void qemu_system_reset_request(ShutdownCause reason)
 594 {
 595     if (reboot_action == REBOOT_ACTION_SHUTDOWN &&
 596         reason != SHUTDOWN_CAUSE_SUBSYSTEM_RESET) {
 597         shutdown_requested = reason;
 598     } else if (!cpus_are_resettable()) {
 599         error_report("cpus are not resettable, terminating");
 600         shutdown_requested = reason;
 601     } else {
 602         reset_requested = reason;
 603     }
 604     cpu_stop_current();
 605     qemu_notify_event();
 606 }
 607
 608 static void qemu_system_suspend(void)
 609 {
 610     pause_all_vcpus();
 611     notifier_list_notify(&suspend_notifiers, NULL);
 612     runstate_set(RUN_STATE_SUSPENDED);
 613     qapi_event_send_suspend();
 614 }
 615
 616 void qemu_system_suspend_request(void)
 617 {
 618     if (runstate_check(RUN_STATE_SUSPENDED)) {
 619         return;
 620     }
 621     suspend_requested = 1;
 622     cpu_stop_current();
 623     qemu_notify_event();
 624 }
 625
 626 void qemu_register_suspend_notifier(Notifier *notifier)
 627 {
 628     notifier_list_add(&suspend_notifiers, notifier);
 629 }
 630
 631 void qemu_system_wakeup_request(WakeupReason reason, Error **errp)
 632 {
 633     trace_system_wakeup_request(reason);
 634
 635     if (!runstate_check(RUN_STATE_SUSPENDED)) {
 636         error_setg(errp,
 637                    "Unable to wake up: guest is not in suspended state");
 638         return;
 639     }
 640     if (!(wakeup_reason_mask & (1 << reason))) {
 641         return;
 642     }
 643     runstate_set(RUN_STATE_RUNNING);
 644     wakeup_reason = reason;
 645     qemu_notify_event();
 646 }
 647
 648 void qemu_system_wakeup_enable(WakeupReason reason, bool enabled)
 649 {
 650     if (enabled) {
 651         wakeup_reason_mask |= (1 << reason);
 652     } else {
 653         wakeup_reason_mask &= ~(1 << reason);
 654     }
 655 }
 656
 657 void qemu_register_wakeup_notifier(Notifier *notifier)
 658 {
 659     notifier_list_add(&wakeup_notifiers, notifier);
 660 }
 661
 662 static bool wakeup_suspend_enabled;
 663
 664 void qemu_register_wakeup_support(void)
 665 {
 666     wakeup_suspend_enabled = true;
 667 }
 668
 669 bool qemu_wakeup_suspend_enabled(void)
 670 {
 671     return wakeup_suspend_enabled;
 672 }
 673
 674 void qemu_system_killed(int signal, pid_t pid)
 675 {
 676     shutdown_signal = signal;
 677     shutdown_pid = pid;
 678     shutdown_action = SHUTDOWN_ACTION_POWEROFF;
 679
 680     /* Cannot call qemu_system_shutdown_request directly because
 681      * we are in a signal handler.
 682      */
 683     shutdown_requested = SHUTDOWN_CAUSE_HOST_SIGNAL;
 684     qemu_notify_event();
 685 }
 686
 687 void qemu_system_shutdown_request_with_code(ShutdownCause reason,
 688                                             int exit_code)
 689 {
 690     shutdown_exit_code = exit_code;
 691     qemu_system_shutdown_request(reason);
 692 }
 693
 694 void qemu_system_shutdown_request(ShutdownCause reason)
 695 {
 696     trace_qemu_system_shutdown_request(reason);
 697     replay_shutdown_request(reason);
 698     shutdown_requested = reason;
 699     qemu_notify_event();
 700 }
 701
 702 static void qemu_system_powerdown(void)
 703 {
 704     qapi_event_send_powerdown();
 705     notifier_list_notify(&powerdown_notifiers, NULL);
 706 }
 707
 708 static void qemu_system_shutdown(ShutdownCause cause)
 709 {
 710     qapi_event_send_shutdown(shutdown_caused_by_guest(cause), cause);
 711     notifier_list_notify(&shutdown_notifiers, &cause);
 712 }
 713
 714 void qemu_system_powerdown_request(void)
 715 {
 716     trace_qemu_system_powerdown_request();
 717     powerdown_requested = 1;
 718     qemu_notify_event();
 719 }
 720
 721 void qemu_register_powerdown_notifier(Notifier *notifier)
 722 {
 723     notifier_list_add(&powerdown_notifiers, notifier);
 724 }
 725
 726 void qemu_register_shutdown_notifier(Notifier *notifier)
 727 {
 728     notifier_list_add(&shutdown_notifiers, notifier);
 729 }
 730
 731 void qemu_system_debug_request(void)
 732 {
 733     debug_requested = 1;
 734     qemu_notify_event();
 735 }
 736
 737 static bool main_loop_should_exit(int *status)
 738 {
 739     RunState r;
 740     ShutdownCause request;
 741
 742     if (qemu_debug_requested()) {
 743         vm_stop(RUN_STATE_DEBUG);
 744     }
 745     if (qemu_suspend_requested()) {
 746         qemu_system_suspend();
 747     }
 748     request = qemu_shutdown_requested();
 749     if (request) {
 750         qemu_kill_report();
 751         qemu_system_shutdown(request);
 752         if (shutdown_action == SHUTDOWN_ACTION_PAUSE) {
 753             vm_stop(RUN_STATE_SHUTDOWN);
 754         } else {
 755             if (shutdown_exit_code != EXIT_SUCCESS) {
 756                 *status = shutdown_exit_code;
 757             } else if (request == SHUTDOWN_CAUSE_GUEST_PANIC &&
 758                 panic_action == PANIC_ACTION_EXIT_FAILURE) {
 759                 *status = EXIT_FAILURE;
 760             }
 761             return true;
 762         }
 763     }
 764     request = qemu_reset_requested();
 765     if (request) {
 766         pause_all_vcpus();
 767         qemu_system_reset(request);
 768         resume_all_vcpus();
 769         /*
 770          * runstate can change in pause_all_vcpus()
 771          * as iothread mutex is unlocked
 772          */
 773         if (!runstate_check(RUN_STATE_RUNNING) &&
 774                 !runstate_check(RUN_STATE_INMIGRATE) &&
 775                 !runstate_check(RUN_STATE_FINISH_MIGRATE)) {
 776             runstate_set(RUN_STATE_PRELAUNCH);
 777         }
 778     }
 779     if (qemu_wakeup_requested()) {
 780         pause_all_vcpus();
 781         qemu_system_wakeup();
 782         notifier_list_notify(&wakeup_notifiers, &wakeup_reason);
 783         wakeup_reason = QEMU_WAKEUP_REASON_NONE;
 784         resume_all_vcpus();
 785         qapi_event_send_wakeup();
 786     }
 787     if (qemu_powerdown_requested()) {
 788         qemu_system_powerdown();
 789     }
 790     if (qemu_vmstop_requested(&r)) {
 791         vm_stop(r);
 792     }
 793     return false;
 794 }
 795
 796 int qemu_main_loop(void)
 797 {
 798     int status = EXIT_SUCCESS;
 799
 800     while (!main_loop_should_exit(&status)) {
 801         main_loop_wait(false);
 802     }
 803
 804     return status;
 805 }
 806
 807 void qemu_add_exit_notifier(Notifier *notify)
 808 {
 809     notifier_list_add(&exit_notifiers, notify);
 810 }
 811
 812 void qemu_remove_exit_notifier(Notifier *notify)
 813 {
 814     notifier_remove(notify);
 815 }
 816
 817 static void qemu_run_exit_notifiers(void)
 818 {
 819     notifier_list_notify(&exit_notifiers, NULL);
 820 }
 821
 822 void qemu_init_subsystems(void)
 823 {
 824     Error *err = NULL;
 825
 826     os_set_line_buffering();
 827
 828     module_call_init(MODULE_INIT_TRACE);
 829
 830     qemu_init_cpu_list();
 831     qemu_init_cpu_loop();
 832     bql_lock();
 833
 834     atexit(qemu_run_exit_notifiers);
 835
 836     module_call_init(MODULE_INIT_QOM);
 837     module_call_init(MODULE_INIT_MIGRATION);
 838
 839     runstate_init();
 840     precopy_infrastructure_init();
 841     postcopy_infrastructure_init();
 842     monitor_init_globals();
 843
 844     if (qcrypto_init(&err) < 0) {
 845         error_reportf_err(err, "cannot initialize crypto: ");
 846         exit(1);
 847     }
 848
 849     os_setup_early_signal_handling();
 850
 851     bdrv_init_with_whitelist();
 852     socket_init();
 853 }
 854
 855
 856 void qemu_cleanup(int status)
 857 {
 858     gdb_exit(status);
 859
 860     /*
 861      * cleaning up the migration object cancels any existing migration
 862      * try to do this early so that it also stops using devices.
 863      */
 864     migration_shutdown();
 865
 866     /*
 867      * Close the exports before draining the block layer. The export
 868      * drivers may have coroutines yielding on it, so we need to clean
 869      * them up before the drain, as otherwise they may be get stuck in
 870      * blk_wait_while_drained().
 871      */
 872     blk_exp_close_all();
 873
 874
 875     /* No more vcpu or device emulation activity beyond this point */
 876     vm_shutdown();
 877     replay_finish();
 878
 879     /*
 880      * We must cancel all block jobs while the block layer is drained,
 881      * or cancelling will be affected by throttling and thus may block
 882      * for an extended period of time.
 883      * Begin the drained section after vm_shutdown() to avoid requests being
 884      * stuck in the BlockBackend's request queue.
 885      * We do not need to end this section, because we do not want any
 886      * requests happening from here on anyway.
 887      */
 888     bdrv_drain_all_begin();
 889     job_cancel_sync_all();
 890     bdrv_close_all();
 891
 892     /* vhost-user must be cleaned up before chardevs.  */
 893     tpm_cleanup();
 894     net_cleanup();
 895     audio_cleanup();
 896     monitor_cleanup();
 897     qemu_chr_cleanup();
 898     user_creatable_cleanup();
 899     /* TODO: unref root container, check all devices are ok */
 900 }