runstate.c (23928B)
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, reason); 445 } else { 446 qemu_devices_reset(reason); 447 } 448 switch (reason) { 449 case SHUTDOWN_CAUSE_NONE: 450 case SHUTDOWN_CAUSE_SUBSYSTEM_RESET: 451 case SHUTDOWN_CAUSE_SNAPSHOT_LOAD: 452 break; 453 default: 454 qapi_event_send_reset(shutdown_caused_by_guest(reason), reason); 455 } 456 cpu_synchronize_all_post_reset(); 457 } 458 459 /* 460 * Wake the VM after suspend. 461 */ 462 static void qemu_system_wakeup(void) 463 { 464 MachineClass *mc; 465 466 mc = current_machine ? MACHINE_GET_CLASS(current_machine) : NULL; 467 468 if (mc && mc->wakeup) { 469 mc->wakeup(current_machine); 470 } 471 } 472 473 void qemu_system_guest_panicked(GuestPanicInformation *info) 474 { 475 qemu_log_mask(LOG_GUEST_ERROR, "Guest crashed"); 476 477 if (current_cpu) { 478 current_cpu->crash_occurred = true; 479 } 480 /* 481 * TODO: Currently the available panic actions are: none, pause, and 482 * shutdown, but in principle debug and reset could be supported as well. 483 * Investigate any potential use cases for the unimplemented actions. 484 */ 485 if (panic_action == PANIC_ACTION_PAUSE 486 || (panic_action == PANIC_ACTION_SHUTDOWN && shutdown_action == SHUTDOWN_ACTION_PAUSE)) { 487 qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_PAUSE, 488 !!info, info); 489 vm_stop(RUN_STATE_GUEST_PANICKED); 490 } else if (panic_action == PANIC_ACTION_SHUTDOWN || 491 panic_action == PANIC_ACTION_EXIT_FAILURE) { 492 qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_POWEROFF, 493 !!info, info); 494 vm_stop(RUN_STATE_GUEST_PANICKED); 495 qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_PANIC); 496 } else { 497 qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_RUN, 498 !!info, info); 499 } 500 501 if (info) { 502 if (info->type == GUEST_PANIC_INFORMATION_TYPE_HYPER_V) { 503 qemu_log_mask(LOG_GUEST_ERROR, "\nHV crash parameters: (%#"PRIx64 504 " %#"PRIx64" %#"PRIx64" %#"PRIx64" %#"PRIx64")\n", 505 info->u.hyper_v.arg1, 506 info->u.hyper_v.arg2, 507 info->u.hyper_v.arg3, 508 info->u.hyper_v.arg4, 509 info->u.hyper_v.arg5); 510 } else if (info->type == GUEST_PANIC_INFORMATION_TYPE_S390) { 511 qemu_log_mask(LOG_GUEST_ERROR, " on cpu %d: %s\n" 512 "PSW: 0x%016" PRIx64 " 0x%016" PRIx64"\n", 513 info->u.s390.core, 514 S390CrashReason_str(info->u.s390.reason), 515 info->u.s390.psw_mask, 516 info->u.s390.psw_addr); 517 } 518 qapi_free_GuestPanicInformation(info); 519 } 520 } 521 522 void qemu_system_guest_crashloaded(GuestPanicInformation *info) 523 { 524 qemu_log_mask(LOG_GUEST_ERROR, "Guest crash loaded"); 525 526 qapi_event_send_guest_crashloaded(GUEST_PANIC_ACTION_RUN, 527 !!info, info); 528 529 if (info) { 530 qapi_free_GuestPanicInformation(info); 531 } 532 } 533 534 void qemu_system_reset_request(ShutdownCause reason) 535 { 536 if (reboot_action == REBOOT_ACTION_SHUTDOWN && 537 reason != SHUTDOWN_CAUSE_SUBSYSTEM_RESET) { 538 shutdown_requested = reason; 539 } else if (!cpus_are_resettable()) { 540 error_report("cpus are not resettable, terminating"); 541 shutdown_requested = reason; 542 } else { 543 reset_requested = reason; 544 } 545 cpu_stop_current(); 546 qemu_notify_event(); 547 } 548 549 static void qemu_system_suspend(void) 550 { 551 pause_all_vcpus(); 552 notifier_list_notify(&suspend_notifiers, NULL); 553 runstate_set(RUN_STATE_SUSPENDED); 554 qapi_event_send_suspend(); 555 } 556 557 void qemu_system_suspend_request(void) 558 { 559 if (runstate_check(RUN_STATE_SUSPENDED)) { 560 return; 561 } 562 suspend_requested = 1; 563 cpu_stop_current(); 564 qemu_notify_event(); 565 } 566 567 void qemu_register_suspend_notifier(Notifier *notifier) 568 { 569 notifier_list_add(&suspend_notifiers, notifier); 570 } 571 572 void qemu_system_wakeup_request(WakeupReason reason, Error **errp) 573 { 574 trace_system_wakeup_request(reason); 575 576 if (!runstate_check(RUN_STATE_SUSPENDED)) { 577 error_setg(errp, 578 "Unable to wake up: guest is not in suspended state"); 579 return; 580 } 581 if (!(wakeup_reason_mask & (1 << reason))) { 582 return; 583 } 584 runstate_set(RUN_STATE_RUNNING); 585 wakeup_reason = reason; 586 qemu_notify_event(); 587 } 588 589 void qemu_system_wakeup_enable(WakeupReason reason, bool enabled) 590 { 591 if (enabled) { 592 wakeup_reason_mask |= (1 << reason); 593 } else { 594 wakeup_reason_mask &= ~(1 << reason); 595 } 596 } 597 598 void qemu_register_wakeup_notifier(Notifier *notifier) 599 { 600 notifier_list_add(&wakeup_notifiers, notifier); 601 } 602 603 static bool wakeup_suspend_enabled; 604 605 void qemu_register_wakeup_support(void) 606 { 607 wakeup_suspend_enabled = true; 608 } 609 610 bool qemu_wakeup_suspend_enabled(void) 611 { 612 return wakeup_suspend_enabled; 613 } 614 615 void qemu_system_killed(int signal, pid_t pid) 616 { 617 shutdown_signal = signal; 618 shutdown_pid = pid; 619 shutdown_action = SHUTDOWN_ACTION_POWEROFF; 620 621 /* Cannot call qemu_system_shutdown_request directly because 622 * we are in a signal handler. 623 */ 624 shutdown_requested = SHUTDOWN_CAUSE_HOST_SIGNAL; 625 qemu_notify_event(); 626 } 627 628 void qemu_system_shutdown_request(ShutdownCause reason) 629 { 630 trace_qemu_system_shutdown_request(reason); 631 replay_shutdown_request(reason); 632 shutdown_requested = reason; 633 qemu_notify_event(); 634 } 635 636 static void qemu_system_powerdown(void) 637 { 638 qapi_event_send_powerdown(); 639 notifier_list_notify(&powerdown_notifiers, NULL); 640 } 641 642 static void qemu_system_shutdown(ShutdownCause cause) 643 { 644 qapi_event_send_shutdown(shutdown_caused_by_guest(cause), cause); 645 notifier_list_notify(&shutdown_notifiers, &cause); 646 } 647 648 void qemu_system_powerdown_request(void) 649 { 650 trace_qemu_system_powerdown_request(); 651 powerdown_requested = 1; 652 qemu_notify_event(); 653 } 654 655 void qemu_register_powerdown_notifier(Notifier *notifier) 656 { 657 notifier_list_add(&powerdown_notifiers, notifier); 658 } 659 660 void qemu_register_shutdown_notifier(Notifier *notifier) 661 { 662 notifier_list_add(&shutdown_notifiers, notifier); 663 } 664 665 void qemu_system_debug_request(void) 666 { 667 debug_requested = 1; 668 qemu_notify_event(); 669 } 670 671 static bool main_loop_should_exit(int *status) 672 { 673 RunState r; 674 ShutdownCause request; 675 676 if (qemu_debug_requested()) { 677 vm_stop(RUN_STATE_DEBUG); 678 } 679 if (qemu_suspend_requested()) { 680 qemu_system_suspend(); 681 } 682 request = qemu_shutdown_requested(); 683 if (request) { 684 qemu_kill_report(); 685 qemu_system_shutdown(request); 686 if (shutdown_action == SHUTDOWN_ACTION_PAUSE) { 687 vm_stop(RUN_STATE_SHUTDOWN); 688 } else { 689 if (request == SHUTDOWN_CAUSE_GUEST_PANIC && 690 panic_action == PANIC_ACTION_EXIT_FAILURE) { 691 *status = EXIT_FAILURE; 692 } 693 return true; 694 } 695 } 696 request = qemu_reset_requested(); 697 if (request) { 698 pause_all_vcpus(); 699 qemu_system_reset(request); 700 resume_all_vcpus(); 701 /* 702 * runstate can change in pause_all_vcpus() 703 * as iothread mutex is unlocked 704 */ 705 if (!runstate_check(RUN_STATE_RUNNING) && 706 !runstate_check(RUN_STATE_INMIGRATE) && 707 !runstate_check(RUN_STATE_FINISH_MIGRATE)) { 708 runstate_set(RUN_STATE_PRELAUNCH); 709 } 710 } 711 if (qemu_wakeup_requested()) { 712 pause_all_vcpus(); 713 qemu_system_wakeup(); 714 notifier_list_notify(&wakeup_notifiers, &wakeup_reason); 715 wakeup_reason = QEMU_WAKEUP_REASON_NONE; 716 resume_all_vcpus(); 717 qapi_event_send_wakeup(); 718 } 719 if (qemu_powerdown_requested()) { 720 qemu_system_powerdown(); 721 } 722 if (qemu_vmstop_requested(&r)) { 723 vm_stop(r); 724 } 725 return false; 726 } 727 728 int qemu_main_loop(void) 729 { 730 int status = EXIT_SUCCESS; 731 #ifdef CONFIG_PROFILER 732 int64_t ti; 733 #endif 734 735 while (!main_loop_should_exit(&status)) { 736 #ifdef CONFIG_PROFILER 737 ti = profile_getclock(); 738 #endif 739 main_loop_wait(false); 740 #ifdef CONFIG_PROFILER 741 dev_time += profile_getclock() - ti; 742 #endif 743 } 744 745 return status; 746 } 747 748 void qemu_add_exit_notifier(Notifier *notify) 749 { 750 notifier_list_add(&exit_notifiers, notify); 751 } 752 753 void qemu_remove_exit_notifier(Notifier *notify) 754 { 755 notifier_remove(notify); 756 } 757 758 static void qemu_run_exit_notifiers(void) 759 { 760 notifier_list_notify(&exit_notifiers, NULL); 761 } 762 763 void qemu_init_subsystems(void) 764 { 765 Error *err = NULL; 766 767 os_set_line_buffering(); 768 769 module_call_init(MODULE_INIT_TRACE); 770 771 qemu_init_cpu_list(); 772 qemu_init_cpu_loop(); 773 qemu_mutex_lock_iothread(); 774 775 atexit(qemu_run_exit_notifiers); 776 777 module_call_init(MODULE_INIT_QOM); 778 module_call_init(MODULE_INIT_MIGRATION); 779 780 runstate_init(); 781 precopy_infrastructure_init(); 782 postcopy_infrastructure_init(); 783 monitor_init_globals(); 784 785 if (qcrypto_init(&err) < 0) { 786 error_reportf_err(err, "cannot initialize crypto: "); 787 exit(1); 788 } 789 790 os_setup_early_signal_handling(); 791 792 bdrv_init_with_whitelist(); 793 socket_init(); 794 } 795 796 797 void qemu_cleanup(void) 798 { 799 gdb_exit(0); 800 801 /* 802 * cleaning up the migration object cancels any existing migration 803 * try to do this early so that it also stops using devices. 804 */ 805 migration_shutdown(); 806 807 /* 808 * Close the exports before draining the block layer. The export 809 * drivers may have coroutines yielding on it, so we need to clean 810 * them up before the drain, as otherwise they may be get stuck in 811 * blk_wait_while_drained(). 812 */ 813 blk_exp_close_all(); 814 815 /* 816 * We must cancel all block jobs while the block layer is drained, 817 * or cancelling will be affected by throttling and thus may block 818 * for an extended period of time. 819 * vm_shutdown() will bdrv_drain_all(), so we may as well include 820 * it in the drained section. 821 * We do not need to end this section, because we do not want any 822 * requests happening from here on anyway. 823 */ 824 bdrv_drain_all_begin(); 825 826 /* No more vcpu or device emulation activity beyond this point */ 827 vm_shutdown(); 828 replay_finish(); 829 830 job_cancel_sync_all(); 831 bdrv_close_all(); 832 833 /* vhost-user must be cleaned up before chardevs. */ 834 tpm_cleanup(); 835 net_cleanup(); 836 audio_cleanup(); 837 monitor_cleanup(); 838 qemu_chr_cleanup(); 839 user_creatable_cleanup(); 840 /* TODO: unref root container, check all devices are ok */ 841 }