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