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