softmmu/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 "exec/gdbstub.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/error-report.h"
  44 #include "qemu/log.h"
  45 #include "qemu/job.h"
  46 #include "qemu/log.h"
  47 #include "qemu/module.h"
  48 #include "qemu/plugin.h"
  49 #include "qemu/sockets.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
  80     { RUN_STATE_DEBUG, RUN_STATE_RUNNING },
  81     { RUN_STATE_DEBUG, RUN_STATE_FINISH_MIGRATE },
  82     { RUN_STATE_DEBUG, RUN_STATE_PRELAUNCH },
  83
  84     { RUN_STATE_INMIGRATE, RUN_STATE_INTERNAL_ERROR },
  85     { RUN_STATE_INMIGRATE, RUN_STATE_IO_ERROR },
  86     { RUN_STATE_INMIGRATE, RUN_STATE_PAUSED },
  87     { RUN_STATE_INMIGRATE, RUN_STATE_RUNNING },
  88     { RUN_STATE_INMIGRATE, RUN_STATE_SHUTDOWN },
  89     { RUN_STATE_INMIGRATE, RUN_STATE_SUSPENDED },
  90     { RUN_STATE_INMIGRATE, RUN_STATE_WATCHDOG },
  91     { RUN_STATE_INMIGRATE, RUN_STATE_GUEST_PANICKED },
  92     { RUN_STATE_INMIGRATE, RUN_STATE_FINISH_MIGRATE },
  93     { RUN_STATE_INMIGRATE, RUN_STATE_PRELAUNCH },
  94     { RUN_STATE_INMIGRATE, RUN_STATE_POSTMIGRATE },
  95     { RUN_STATE_INMIGRATE, RUN_STATE_COLO },
  96
  97     { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PAUSED },
  98     { RUN_STATE_INTERNAL_ERROR, RUN_STATE_FINISH_MIGRATE },
  99     { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PRELAUNCH },
 100
 101     { RUN_STATE_IO_ERROR, RUN_STATE_RUNNING },
 102     { RUN_STATE_IO_ERROR, RUN_STATE_FINISH_MIGRATE },
 103     { RUN_STATE_IO_ERROR, RUN_STATE_PRELAUNCH },
 104
 105     { RUN_STATE_PAUSED, RUN_STATE_RUNNING },
 106     { RUN_STATE_PAUSED, RUN_STATE_FINISH_MIGRATE },
 107     { RUN_STATE_PAUSED, RUN_STATE_POSTMIGRATE },
 108     { RUN_STATE_PAUSED, RUN_STATE_PRELAUNCH },
 109     { RUN_STATE_PAUSED, RUN_STATE_COLO},
 110
 111     { RUN_STATE_POSTMIGRATE, RUN_STATE_RUNNING },
 112     { RUN_STATE_POSTMIGRATE, RUN_STATE_FINISH_MIGRATE },
 113     { RUN_STATE_POSTMIGRATE, RUN_STATE_PRELAUNCH },
 114
 115     { RUN_STATE_PRELAUNCH, RUN_STATE_RUNNING },
 116     { RUN_STATE_PRELAUNCH, RUN_STATE_FINISH_MIGRATE },
 117     { RUN_STATE_PRELAUNCH, RUN_STATE_INMIGRATE },
 118
 119     { RUN_STATE_FINISH_MIGRATE, RUN_STATE_RUNNING },
 120     { RUN_STATE_FINISH_MIGRATE, RUN_STATE_PAUSED },
 121     { RUN_STATE_FINISH_MIGRATE, RUN_STATE_POSTMIGRATE },
 122     { RUN_STATE_FINISH_MIGRATE, RUN_STATE_PRELAUNCH },
 123     { RUN_STATE_FINISH_MIGRATE, RUN_STATE_COLO},
 124
 125     { RUN_STATE_RESTORE_VM, RUN_STATE_RUNNING },
 126     { RUN_STATE_RESTORE_VM, RUN_STATE_PRELAUNCH },
 127
 128     { RUN_STATE_COLO, RUN_STATE_RUNNING },
 129     { RUN_STATE_COLO, RUN_STATE_PRELAUNCH },
 130     { RUN_STATE_COLO, RUN_STATE_SHUTDOWN},
 131
 132     { RUN_STATE_RUNNING, RUN_STATE_DEBUG },
 133     { RUN_STATE_RUNNING, RUN_STATE_INTERNAL_ERROR },
 134     { RUN_STATE_RUNNING, RUN_STATE_IO_ERROR },
 135     { RUN_STATE_RUNNING, RUN_STATE_PAUSED },
 136     { RUN_STATE_RUNNING, RUN_STATE_FINISH_MIGRATE },
 137     { RUN_STATE_RUNNING, RUN_STATE_RESTORE_VM },
 138     { RUN_STATE_RUNNING, RUN_STATE_SAVE_VM },
 139     { RUN_STATE_RUNNING, RUN_STATE_SHUTDOWN },
 140     { RUN_STATE_RUNNING, RUN_STATE_WATCHDOG },
 141     { RUN_STATE_RUNNING, RUN_STATE_GUEST_PANICKED },
 142     { RUN_STATE_RUNNING, RUN_STATE_COLO},
 143
 144     { RUN_STATE_SAVE_VM, RUN_STATE_RUNNING },
 145
 146     { RUN_STATE_SHUTDOWN, RUN_STATE_PAUSED },
 147     { RUN_STATE_SHUTDOWN, RUN_STATE_FINISH_MIGRATE },
 148     { RUN_STATE_SHUTDOWN, RUN_STATE_PRELAUNCH },
 149     { RUN_STATE_SHUTDOWN, RUN_STATE_COLO },
 150
 151     { RUN_STATE_DEBUG, RUN_STATE_SUSPENDED },
 152     { RUN_STATE_RUNNING, RUN_STATE_SUSPENDED },
 153     { RUN_STATE_SUSPENDED, RUN_STATE_RUNNING },
 154     { RUN_STATE_SUSPENDED, RUN_STATE_FINISH_MIGRATE },
 155     { RUN_STATE_SUSPENDED, RUN_STATE_PRELAUNCH },
 156     { RUN_STATE_SUSPENDED, RUN_STATE_COLO},
 157
 158     { RUN_STATE_WATCHDOG, RUN_STATE_RUNNING },
 159     { RUN_STATE_WATCHDOG, RUN_STATE_FINISH_MIGRATE },
 160     { RUN_STATE_WATCHDOG, RUN_STATE_PRELAUNCH },
 161     { RUN_STATE_WATCHDOG, RUN_STATE_COLO},
 162
 163     { RUN_STATE_GUEST_PANICKED, RUN_STATE_RUNNING },
 164     { RUN_STATE_GUEST_PANICKED, RUN_STATE_FINISH_MIGRATE },
 165     { RUN_STATE_GUEST_PANICKED, RUN_STATE_PRELAUNCH },
 166
 167     { RUN_STATE__MAX, RUN_STATE__MAX },
 168 };
 169
 170 static bool runstate_valid_transitions[RUN_STATE__MAX][RUN_STATE__MAX];
 171
 172 bool runstate_check(RunState state)
 173 {
 174     return current_run_state == state;
 175 }
 176
 177 bool runstate_store(char *str, size_t size)
 178 {
 179     const char *state = RunState_str(current_run_state);
 180     size_t len = strlen(state) + 1;
 181
 182     if (len > size) {
 183         return false;
 184     }
 185     memcpy(str, state, len);
 186     return true;
 187 }
 188
 189 static void runstate_init(void)
 190 {
 191     const RunStateTransition *p;
 192
 193     memset(&runstate_valid_transitions, 0, sizeof(runstate_valid_transitions));
 194     for (p = &runstate_transitions_def[0]; p->from != RUN_STATE__MAX; p++) {
 195         runstate_valid_transitions[p->from][p->to] = true;
 196     }
 197
 198     qemu_mutex_init(&vmstop_lock);
 199 }
 200
 201 /* This function will abort() on invalid state transitions */
 202 void runstate_set(RunState new_state)
 203 {
 204     assert(new_state < RUN_STATE__MAX);
 205
 206     trace_runstate_set(current_run_state, RunState_str(current_run_state),
 207                        new_state, RunState_str(new_state));
 208
 209     if (current_run_state == new_state) {
 210         return;
 211     }
 212
 213     if (!runstate_valid_transitions[current_run_state][new_state]) {
 214         error_report("invalid runstate transition: '%s' -> '%s'",
 215                      RunState_str(current_run_state),
 216                      RunState_str(new_state));
 217         abort();
 218     }
 219
 220     current_run_state = new_state;
 221 }
 222
 223 bool runstate_is_running(void)
 224 {
 225     return runstate_check(RUN_STATE_RUNNING);
 226 }
 227
 228 bool runstate_needs_reset(void)
 229 {
 230     return runstate_check(RUN_STATE_INTERNAL_ERROR) ||
 231         runstate_check(RUN_STATE_SHUTDOWN);
 232 }
 233
 234 StatusInfo *qmp_query_status(Error **errp)
 235 {
 236     StatusInfo *info = g_malloc0(sizeof(*info));
 237
 238     info->running = runstate_is_running();
 239     info->singlestep = singlestep;
 240     info->status = current_run_state;
 241
 242     return info;
 243 }
 244
 245 bool qemu_vmstop_requested(RunState *r)
 246 {
 247     qemu_mutex_lock(&vmstop_lock);
 248     *r = vmstop_requested;
 249     vmstop_requested = RUN_STATE__MAX;
 250     qemu_mutex_unlock(&vmstop_lock);
 251     return *r < RUN_STATE__MAX;
 252 }
 253
 254 void qemu_system_vmstop_request_prepare(void)
 255 {
 256     qemu_mutex_lock(&vmstop_lock);
 257 }
 258
 259 void qemu_system_vmstop_request(RunState state)
 260 {
 261     vmstop_requested = state;
 262     qemu_mutex_unlock(&vmstop_lock);
 263     qemu_notify_event();
 264 }
 265 struct VMChangeStateEntry {
 266     VMChangeStateHandler *cb;
 267     void *opaque;
 268     QTAILQ_ENTRY(VMChangeStateEntry) entries;
 269     int priority;
 270 };
 271
 272 static QTAILQ_HEAD(, VMChangeStateEntry) vm_change_state_head =
 273     QTAILQ_HEAD_INITIALIZER(vm_change_state_head);
 274
 275 /**
 276  * qemu_add_vm_change_state_handler_prio:
 277  * @cb: the callback to invoke
 278  * @opaque: user data passed to the callback
 279  * @priority: low priorities execute first when the vm runs and the reverse is
 280  *            true when the vm stops
 281  *
 282  * Register a callback function that is invoked when the vm starts or stops
 283  * running.
 284  *
 285  * Returns: an entry to be freed using qemu_del_vm_change_state_handler()
 286  */
 287 VMChangeStateEntry *qemu_add_vm_change_state_handler_prio(
 288         VMChangeStateHandler *cb, void *opaque, int priority)
 289 {
 290     VMChangeStateEntry *e;
 291     VMChangeStateEntry *other;
 292
 293     e = g_malloc0(sizeof(*e));
 294     e->cb = cb;
 295     e->opaque = opaque;
 296     e->priority = priority;
 297
 298     /* Keep list sorted in ascending priority order */
 299     QTAILQ_FOREACH(other, &vm_change_state_head, entries) {
 300         if (priority < other->priority) {
 301             QTAILQ_INSERT_BEFORE(other, e, entries);
 302             return e;
 303         }
 304     }
 305
 306     QTAILQ_INSERT_TAIL(&vm_change_state_head, e, entries);
 307     return e;
 308 }
 309
 310 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
 311                                                      void *opaque)
 312 {
 313     return qemu_add_vm_change_state_handler_prio(cb, opaque, 0);
 314 }
 315
 316 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
 317 {
 318     QTAILQ_REMOVE(&vm_change_state_head, e, entries);
 319     g_free(e);
 320 }
 321
 322 void vm_state_notify(bool running, RunState state)
 323 {
 324     VMChangeStateEntry *e, *next;
 325
 326     trace_vm_state_notify(running, state, RunState_str(state));
 327
 328     if (running) {
 329         QTAILQ_FOREACH_SAFE(e, &vm_change_state_head, entries, next) {
 330             e->cb(e->opaque, running, state);
 331         }
 332     } else {
 333         QTAILQ_FOREACH_REVERSE_SAFE(e, &vm_change_state_head, entries, next) {
 334             e->cb(e->opaque, running, state);
 335         }
 336     }
 337 }
 338
 339 static ShutdownCause reset_requested;
 340 static ShutdownCause shutdown_requested;
 341 static int shutdown_signal;
 342 static pid_t shutdown_pid;
 343 static int powerdown_requested;
 344 static int debug_requested;
 345 static int suspend_requested;
 346 static WakeupReason wakeup_reason;
 347 static NotifierList powerdown_notifiers =
 348     NOTIFIER_LIST_INITIALIZER(powerdown_notifiers);
 349 static NotifierList suspend_notifiers =
 350     NOTIFIER_LIST_INITIALIZER(suspend_notifiers);
 351 static NotifierList wakeup_notifiers =
 352     NOTIFIER_LIST_INITIALIZER(wakeup_notifiers);
 353 static NotifierList shutdown_notifiers =
 354     NOTIFIER_LIST_INITIALIZER(shutdown_notifiers);
 355 static uint32_t wakeup_reason_mask = ~(1 << QEMU_WAKEUP_REASON_NONE);
 356
 357 ShutdownCause qemu_shutdown_requested_get(void)
 358 {
 359     return shutdown_requested;
 360 }
 361
 362 ShutdownCause qemu_reset_requested_get(void)
 363 {
 364     return reset_requested;
 365 }
 366
 367 static int qemu_shutdown_requested(void)
 368 {
 369     return qatomic_xchg(&shutdown_requested, SHUTDOWN_CAUSE_NONE);
 370 }
 371
 372 static void qemu_kill_report(void)
 373 {
 374     if (!qtest_driver() && shutdown_signal) {
 375         if (shutdown_pid == 0) {
 376             /* This happens for eg ^C at the terminal, so it's worth
 377              * avoiding printing an odd message in that case.
 378              */
 379             error_report("terminating on signal %d", shutdown_signal);
 380         } else {
 381             char *shutdown_cmd = qemu_get_pid_name(shutdown_pid);
 382
 383             error_report("terminating on signal %d from pid " FMT_pid " (%s)",
 384                          shutdown_signal, shutdown_pid,
 385                          shutdown_cmd ? shutdown_cmd : "<unknown process>");
 386             g_free(shutdown_cmd);
 387         }
 388         shutdown_signal = 0;
 389     }
 390 }
 391
 392 static ShutdownCause qemu_reset_requested(void)
 393 {
 394     ShutdownCause r = reset_requested;
 395
 396     if (r && replay_checkpoint(CHECKPOINT_RESET_REQUESTED)) {
 397         reset_requested = SHUTDOWN_CAUSE_NONE;
 398         return r;
 399     }
 400     return SHUTDOWN_CAUSE_NONE;
 401 }
 402
 403 static int qemu_suspend_requested(void)
 404 {
 405     int r = suspend_requested;
 406     if (r && replay_checkpoint(CHECKPOINT_SUSPEND_REQUESTED)) {
 407         suspend_requested = 0;
 408         return r;
 409     }
 410     return false;
 411 }
 412
 413 static WakeupReason qemu_wakeup_requested(void)
 414 {
 415     return wakeup_reason;
 416 }
 417
 418 static int qemu_powerdown_requested(void)
 419 {
 420     int r = powerdown_requested;
 421     powerdown_requested = 0;
 422     return r;
 423 }
 424
 425 static int qemu_debug_requested(void)
 426 {
 427     int r = debug_requested;
 428     debug_requested = 0;
 429     return r;
 430 }
 431
 432 /*
 433  * Reset the VM. Issue an event unless @reason is SHUTDOWN_CAUSE_NONE.
 434  */
 435 void qemu_system_reset(ShutdownCause reason)
 436 {
 437     MachineClass *mc;
 438
 439     mc = current_machine ? MACHINE_GET_CLASS(current_machine) : NULL;
 440
 441     cpu_synchronize_all_states();
 442
 443     if (mc && mc->reset) {
 444         mc->reset(current_machine);
 445     } else {
 446         qemu_devices_reset();
 447     }
 448     if (reason && reason != SHUTDOWN_CAUSE_SUBSYSTEM_RESET) {
 449         qapi_event_send_reset(shutdown_caused_by_guest(reason), reason);
 450     }
 451     cpu_synchronize_all_post_reset();
 452 }
 453
 454 /*
 455  * Wake the VM after suspend.
 456  */
 457 static void qemu_system_wakeup(void)
 458 {
 459     MachineClass *mc;
 460
 461     mc = current_machine ? MACHINE_GET_CLASS(current_machine) : NULL;
 462
 463     if (mc && mc->wakeup) {
 464         mc->wakeup(current_machine);
 465     }
 466 }
 467
 468 void qemu_system_guest_panicked(GuestPanicInformation *info)
 469 {
 470     qemu_log_mask(LOG_GUEST_ERROR, "Guest crashed");
 471
 472     if (current_cpu) {
 473         current_cpu->crash_occurred = true;
 474     }
 475     /*
 476      * TODO:  Currently the available panic actions are: none, pause, and
 477      * shutdown, but in principle debug and reset could be supported as well.
 478      * Investigate any potential use cases for the unimplemented actions.
 479      */
 480     if (panic_action == PANIC_ACTION_PAUSE
 481         || (panic_action == PANIC_ACTION_SHUTDOWN && shutdown_action == SHUTDOWN_ACTION_PAUSE)) {
 482         qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_PAUSE,
 483                                         !!info, info);
 484         vm_stop(RUN_STATE_GUEST_PANICKED);
 485     } else if (panic_action == PANIC_ACTION_SHUTDOWN ||
 486                panic_action == PANIC_ACTION_EXIT_FAILURE) {
 487         qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_POWEROFF,
 488                                        !!info, info);
 489         vm_stop(RUN_STATE_GUEST_PANICKED);
 490         qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_PANIC);
 491     } else {
 492         qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_RUN,
 493                                         !!info, info);
 494     }
 495
 496     if (info) {
 497         if (info->type == GUEST_PANIC_INFORMATION_TYPE_HYPER_V) {
 498             qemu_log_mask(LOG_GUEST_ERROR, "\nHV crash parameters: (%#"PRIx64
 499                           " %#"PRIx64" %#"PRIx64" %#"PRIx64" %#"PRIx64")\n",
 500                           info->u.hyper_v.arg1,
 501                           info->u.hyper_v.arg2,
 502                           info->u.hyper_v.arg3,
 503                           info->u.hyper_v.arg4,
 504                           info->u.hyper_v.arg5);
 505         } else if (info->type == GUEST_PANIC_INFORMATION_TYPE_S390) {
 506             qemu_log_mask(LOG_GUEST_ERROR, " on cpu %d: %s\n"
 507                           "PSW: 0x%016" PRIx64 " 0x%016" PRIx64"\n",
 508                           info->u.s390.core,
 509                           S390CrashReason_str(info->u.s390.reason),
 510                           info->u.s390.psw_mask,
 511                           info->u.s390.psw_addr);
 512         }
 513         qapi_free_GuestPanicInformation(info);
 514     }
 515 }
 516
 517 void qemu_system_guest_crashloaded(GuestPanicInformation *info)
 518 {
 519     qemu_log_mask(LOG_GUEST_ERROR, "Guest crash loaded");
 520
 521     qapi_event_send_guest_crashloaded(GUEST_PANIC_ACTION_RUN,
 522                                    !!info, info);
 523
 524     if (info) {
 525         qapi_free_GuestPanicInformation(info);
 526     }
 527 }
 528
 529 void qemu_system_reset_request(ShutdownCause reason)
 530 {
 531     if (reboot_action == REBOOT_ACTION_SHUTDOWN &&
 532         reason != SHUTDOWN_CAUSE_SUBSYSTEM_RESET) {
 533         shutdown_requested = reason;
 534     } else if (!cpus_are_resettable()) {
 535         error_report("cpus are not resettable, terminating");
 536         shutdown_requested = reason;
 537     } else {
 538         reset_requested = reason;
 539     }
 540     cpu_stop_current();
 541     qemu_notify_event();
 542 }
 543
 544 static void qemu_system_suspend(void)
 545 {
 546     pause_all_vcpus();
 547     notifier_list_notify(&suspend_notifiers, NULL);
 548     runstate_set(RUN_STATE_SUSPENDED);
 549     qapi_event_send_suspend();
 550 }
 551
 552 void qemu_system_suspend_request(void)
 553 {
 554     if (runstate_check(RUN_STATE_SUSPENDED)) {
 555         return;
 556     }
 557     suspend_requested = 1;
 558     cpu_stop_current();
 559     qemu_notify_event();
 560 }
 561
 562 void qemu_register_suspend_notifier(Notifier *notifier)
 563 {
 564     notifier_list_add(&suspend_notifiers, notifier);
 565 }
 566
 567 void qemu_system_wakeup_request(WakeupReason reason, Error **errp)
 568 {
 569     trace_system_wakeup_request(reason);
 570
 571     if (!runstate_check(RUN_STATE_SUSPENDED)) {
 572         error_setg(errp,
 573                    "Unable to wake up: guest is not in suspended state");
 574         return;
 575     }
 576     if (!(wakeup_reason_mask & (1 << reason))) {
 577         return;
 578     }
 579     runstate_set(RUN_STATE_RUNNING);
 580     wakeup_reason = reason;
 581     qemu_notify_event();
 582 }
 583
 584 void qemu_system_wakeup_enable(WakeupReason reason, bool enabled)
 585 {
 586     if (enabled) {
 587         wakeup_reason_mask |= (1 << reason);
 588     } else {
 589         wakeup_reason_mask &= ~(1 << reason);
 590     }
 591 }
 592
 593 void qemu_register_wakeup_notifier(Notifier *notifier)
 594 {
 595     notifier_list_add(&wakeup_notifiers, notifier);
 596 }
 597
 598 static bool wakeup_suspend_enabled;
 599
 600 void qemu_register_wakeup_support(void)
 601 {
 602     wakeup_suspend_enabled = true;
 603 }
 604
 605 bool qemu_wakeup_suspend_enabled(void)
 606 {
 607     return wakeup_suspend_enabled;
 608 }
 609
 610 void qemu_system_killed(int signal, pid_t pid)
 611 {
 612     shutdown_signal = signal;
 613     shutdown_pid = pid;
 614     shutdown_action = SHUTDOWN_ACTION_POWEROFF;
 615
 616     /* Cannot call qemu_system_shutdown_request directly because
 617      * we are in a signal handler.
 618      */
 619     shutdown_requested = SHUTDOWN_CAUSE_HOST_SIGNAL;
 620     qemu_notify_event();
 621 }
 622
 623 void qemu_system_shutdown_request(ShutdownCause reason)
 624 {
 625     trace_qemu_system_shutdown_request(reason);
 626     replay_shutdown_request(reason);
 627     shutdown_requested = reason;
 628     qemu_notify_event();
 629 }
 630
 631 static void qemu_system_powerdown(void)
 632 {
 633     qapi_event_send_powerdown();
 634     notifier_list_notify(&powerdown_notifiers, NULL);
 635 }
 636
 637 static void qemu_system_shutdown(ShutdownCause cause)
 638 {
 639     qapi_event_send_shutdown(shutdown_caused_by_guest(cause), cause);
 640     notifier_list_notify(&shutdown_notifiers, &cause);
 641 }
 642
 643 void qemu_system_powerdown_request(void)
 644 {
 645     trace_qemu_system_powerdown_request();
 646     powerdown_requested = 1;
 647     qemu_notify_event();
 648 }
 649
 650 void qemu_register_powerdown_notifier(Notifier *notifier)
 651 {
 652     notifier_list_add(&powerdown_notifiers, notifier);
 653 }
 654
 655 void qemu_register_shutdown_notifier(Notifier *notifier)
 656 {
 657     notifier_list_add(&shutdown_notifiers, notifier);
 658 }
 659
 660 void qemu_system_debug_request(void)
 661 {
 662     debug_requested = 1;
 663     qemu_notify_event();
 664 }
 665
 666 static bool main_loop_should_exit(int *status)
 667 {
 668     RunState r;
 669     ShutdownCause request;
 670
 671     if (qemu_debug_requested()) {
 672         vm_stop(RUN_STATE_DEBUG);
 673     }
 674     if (qemu_suspend_requested()) {
 675         qemu_system_suspend();
 676     }
 677     request = qemu_shutdown_requested();
 678     if (request) {
 679         qemu_kill_report();
 680         qemu_system_shutdown(request);
 681         if (shutdown_action == SHUTDOWN_ACTION_PAUSE) {
 682             vm_stop(RUN_STATE_SHUTDOWN);
 683         } else {
 684             if (request == SHUTDOWN_CAUSE_GUEST_PANIC &&
 685                 panic_action == PANIC_ACTION_EXIT_FAILURE) {
 686                 *status = EXIT_FAILURE;
 687             }
 688             return true;
 689         }
 690     }
 691     request = qemu_reset_requested();
 692     if (request) {
 693         pause_all_vcpus();
 694         qemu_system_reset(request);
 695         resume_all_vcpus();
 696         /*
 697          * runstate can change in pause_all_vcpus()
 698          * as iothread mutex is unlocked
 699          */
 700         if (!runstate_check(RUN_STATE_RUNNING) &&
 701                 !runstate_check(RUN_STATE_INMIGRATE) &&
 702                 !runstate_check(RUN_STATE_FINISH_MIGRATE)) {
 703             runstate_set(RUN_STATE_PRELAUNCH);
 704         }
 705     }
 706     if (qemu_wakeup_requested()) {
 707         pause_all_vcpus();
 708         qemu_system_wakeup();
 709         notifier_list_notify(&wakeup_notifiers, &wakeup_reason);
 710         wakeup_reason = QEMU_WAKEUP_REASON_NONE;
 711         resume_all_vcpus();
 712         qapi_event_send_wakeup();
 713     }
 714     if (qemu_powerdown_requested()) {
 715         qemu_system_powerdown();
 716     }
 717     if (qemu_vmstop_requested(&r)) {
 718         vm_stop(r);
 719     }
 720     return false;
 721 }
 722
 723 int qemu_main_loop(void)
 724 {
 725     int status = EXIT_SUCCESS;
 726 #ifdef CONFIG_PROFILER
 727     int64_t ti;
 728 #endif
 729
 730     while (!main_loop_should_exit(&status)) {
 731 #ifdef CONFIG_PROFILER
 732         ti = profile_getclock();
 733 #endif
 734         main_loop_wait(false);
 735 #ifdef CONFIG_PROFILER
 736         dev_time += profile_getclock() - ti;
 737 #endif
 738     }
 739
 740     return status;
 741 }
 742
 743 void qemu_add_exit_notifier(Notifier *notify)
 744 {
 745     notifier_list_add(&exit_notifiers, notify);
 746 }
 747
 748 void qemu_remove_exit_notifier(Notifier *notify)
 749 {
 750     notifier_remove(notify);
 751 }
 752
 753 static void qemu_run_exit_notifiers(void)
 754 {
 755     notifier_list_notify(&exit_notifiers, NULL);
 756 }
 757
 758 void qemu_init_subsystems(void)
 759 {
 760     Error *err = NULL;
 761
 762     os_set_line_buffering();
 763
 764     module_call_init(MODULE_INIT_TRACE);
 765
 766     qemu_init_cpu_list();
 767     qemu_init_cpu_loop();
 768     qemu_mutex_lock_iothread();
 769
 770     atexit(qemu_run_exit_notifiers);
 771
 772     module_call_init(MODULE_INIT_QOM);
 773     module_call_init(MODULE_INIT_MIGRATION);
 774
 775     runstate_init();
 776     precopy_infrastructure_init();
 777     postcopy_infrastructure_init();
 778     monitor_init_globals();
 779
 780     if (qcrypto_init(&err) < 0) {
 781         error_reportf_err(err, "cannot initialize crypto: ");
 782         exit(1);
 783     }
 784
 785     os_setup_early_signal_handling();
 786
 787     bdrv_init_with_whitelist();
 788     socket_init();
 789 }
 790
 791
 792 void qemu_cleanup(void)
 793 {
 794     gdb_exit(0);
 795
 796     /*
 797      * cleaning up the migration object cancels any existing migration
 798      * try to do this early so that it also stops using devices.
 799      */
 800     migration_shutdown();
 801
 802     /*
 803      * Close the exports before draining the block layer. The export
 804      * drivers may have coroutines yielding on it, so we need to clean
 805      * them up before the drain, as otherwise they may be get stuck in
 806      * blk_wait_while_drained().
 807      */
 808     blk_exp_close_all();
 809
 810     /*
 811      * We must cancel all block jobs while the block layer is drained,
 812      * or cancelling will be affected by throttling and thus may block
 813      * for an extended period of time.
 814      * vm_shutdown() will bdrv_drain_all(), so we may as well include
 815      * it in the drained section.
 816      * We do not need to end this section, because we do not want any
 817      * requests happening from here on anyway.
 818      */
 819     bdrv_drain_all_begin();
 820
 821     /* No more vcpu or device emulation activity beyond this point */
 822     vm_shutdown();
 823     replay_finish();
 824
 825     job_cancel_sync_all();
 826     bdrv_close_all();
 827
 828     /* vhost-user must be cleaned up before chardevs.  */
 829     tpm_cleanup();
 830     net_cleanup();
 831     audio_cleanup();
 832     monitor_cleanup();
 833     qemu_chr_cleanup();
 834     user_creatable_cleanup();
 835     /* TODO: unref root container, check all devices are ok */
 836 }