2 * QEMU main system emulation loop
4 * Copyright (c) 2003-2020 QEMU contributors
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
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"
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"
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"
64 static NotifierList exit_notifiers
=
65 NOTIFIER_LIST_INITIALIZER(exit_notifiers
);
67 static RunState current_run_state
= RUN_STATE_PRELAUNCH
;
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
;
78 static const RunStateTransition runstate_transitions_def
[] = {
79 { RUN_STATE_PRELAUNCH
, RUN_STATE_INMIGRATE
},
80 { RUN_STATE_PRELAUNCH
, RUN_STATE_SUSPENDED
},
82 { RUN_STATE_DEBUG
, RUN_STATE_RUNNING
},
83 { RUN_STATE_DEBUG
, RUN_STATE_FINISH_MIGRATE
},
84 { RUN_STATE_DEBUG
, RUN_STATE_PRELAUNCH
},
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
},
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
},
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
},
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
},
114 { RUN_STATE_POSTMIGRATE
, RUN_STATE_RUNNING
},
115 { RUN_STATE_POSTMIGRATE
, RUN_STATE_FINISH_MIGRATE
},
116 { RUN_STATE_POSTMIGRATE
, RUN_STATE_PRELAUNCH
},
118 { RUN_STATE_PRELAUNCH
, RUN_STATE_RUNNING
},
119 { RUN_STATE_PRELAUNCH
, RUN_STATE_FINISH_MIGRATE
},
120 { RUN_STATE_PRELAUNCH
, RUN_STATE_INMIGRATE
},
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
},
134 { RUN_STATE_RESTORE_VM
, RUN_STATE_RUNNING
},
135 { RUN_STATE_RESTORE_VM
, RUN_STATE_PRELAUNCH
},
136 { RUN_STATE_RESTORE_VM
, RUN_STATE_SUSPENDED
},
138 { RUN_STATE_COLO
, RUN_STATE_RUNNING
},
139 { RUN_STATE_COLO
, RUN_STATE_PRELAUNCH
},
140 { RUN_STATE_COLO
, RUN_STATE_SHUTDOWN
},
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
},
154 { RUN_STATE_SAVE_VM
, RUN_STATE_RUNNING
},
155 { RUN_STATE_SAVE_VM
, RUN_STATE_SUSPENDED
},
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
},
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
},
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
},
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
},
182 { RUN_STATE__MAX
, RUN_STATE__MAX
},
185 static bool runstate_valid_transitions
[RUN_STATE__MAX
][RUN_STATE__MAX
];
187 bool runstate_check(RunState state
)
189 return current_run_state
== state
;
192 static void runstate_init(void)
194 const RunStateTransition
*p
;
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;
201 qemu_mutex_init(&vmstop_lock
);
204 /* This function will abort() on invalid state transitions */
205 void runstate_set(RunState new_state
)
207 assert(new_state
< RUN_STATE__MAX
);
209 trace_runstate_set(current_run_state
, RunState_str(current_run_state
),
210 new_state
, RunState_str(new_state
));
212 if (current_run_state
== new_state
) {
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
));
223 current_run_state
= new_state
;
226 RunState
runstate_get(void)
228 return current_run_state
;
231 bool runstate_is_running(void)
233 return runstate_check(RUN_STATE_RUNNING
);
236 bool runstate_needs_reset(void)
238 return runstate_check(RUN_STATE_INTERNAL_ERROR
) ||
239 runstate_check(RUN_STATE_SHUTDOWN
);
242 StatusInfo
*qmp_query_status(Error
**errp
)
244 StatusInfo
*info
= g_malloc0(sizeof(*info
));
245 AccelState
*accel
= current_accel();
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.
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
;
260 bool qemu_vmstop_requested(RunState
*r
)
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
;
269 void qemu_system_vmstop_request_prepare(void)
271 qemu_mutex_lock(&vmstop_lock
);
274 void qemu_system_vmstop_request(RunState state
)
276 vmstop_requested
= state
;
277 qemu_mutex_unlock(&vmstop_lock
);
280 struct VMChangeStateEntry
{
281 VMChangeStateHandler
*cb
;
282 VMChangeStateHandler
*prepare_cb
;
284 QTAILQ_ENTRY(VMChangeStateEntry
) entries
;
288 static QTAILQ_HEAD(, VMChangeStateEntry
) vm_change_state_head
=
289 QTAILQ_HEAD_INITIALIZER(vm_change_state_head
);
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
298 * Register a callback function that is invoked when the vm starts or stops
301 * Returns: an entry to be freed using qemu_del_vm_change_state_handler()
303 VMChangeStateEntry
*qemu_add_vm_change_state_handler_prio(
304 VMChangeStateHandler
*cb
, void *opaque
, int priority
)
306 return qemu_add_vm_change_state_handler_prio_full(cb
, NULL
, opaque
,
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
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.
325 * Returns: an entry to be freed using qemu_del_vm_change_state_handler()
328 qemu_add_vm_change_state_handler_prio_full(VMChangeStateHandler
*cb
,
329 VMChangeStateHandler
*prepare_cb
,
330 void *opaque
, int priority
)
332 VMChangeStateEntry
*e
;
333 VMChangeStateEntry
*other
;
335 e
= g_malloc0(sizeof(*e
));
337 e
->prepare_cb
= prepare_cb
;
339 e
->priority
= priority
;
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
);
349 QTAILQ_INSERT_TAIL(&vm_change_state_head
, e
, entries
);
353 VMChangeStateEntry
*qemu_add_vm_change_state_handler(VMChangeStateHandler
*cb
,
356 return qemu_add_vm_change_state_handler_prio(cb
, opaque
, 0);
359 void qemu_del_vm_change_state_handler(VMChangeStateEntry
*e
)
361 QTAILQ_REMOVE(&vm_change_state_head
, e
, entries
);
365 void vm_state_notify(bool running
, RunState state
)
367 VMChangeStateEntry
*e
, *next
;
369 trace_vm_state_notify(running
, state
, RunState_str(state
));
372 QTAILQ_FOREACH_SAFE(e
, &vm_change_state_head
, entries
, next
) {
374 e
->prepare_cb(e
->opaque
, running
, state
);
378 QTAILQ_FOREACH_SAFE(e
, &vm_change_state_head
, entries
, next
) {
379 e
->cb(e
->opaque
, running
, state
);
382 QTAILQ_FOREACH_REVERSE_SAFE(e
, &vm_change_state_head
, entries
, next
) {
384 e
->prepare_cb(e
->opaque
, running
, state
);
388 QTAILQ_FOREACH_REVERSE_SAFE(e
, &vm_change_state_head
, entries
, next
) {
389 e
->cb(e
->opaque
, running
, state
);
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
);
413 ShutdownCause
qemu_shutdown_requested_get(void)
415 return shutdown_requested
;
418 ShutdownCause
qemu_reset_requested_get(void)
420 return reset_requested
;
423 static int qemu_shutdown_requested(void)
425 return qatomic_xchg(&shutdown_requested
, SHUTDOWN_CAUSE_NONE
);
428 static void qemu_kill_report(void)
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.
435 error_report("terminating on signal %d", shutdown_signal
);
437 char *shutdown_cmd
= qemu_get_pid_name(shutdown_pid
);
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
);
448 static ShutdownCause
qemu_reset_requested(void)
450 ShutdownCause r
= reset_requested
;
452 if (r
&& replay_checkpoint(CHECKPOINT_RESET_REQUESTED
)) {
453 reset_requested
= SHUTDOWN_CAUSE_NONE
;
456 return SHUTDOWN_CAUSE_NONE
;
459 static int qemu_suspend_requested(void)
461 int r
= suspend_requested
;
462 if (r
&& replay_checkpoint(CHECKPOINT_SUSPEND_REQUESTED
)) {
463 suspend_requested
= 0;
469 static WakeupReason
qemu_wakeup_requested(void)
471 return wakeup_reason
;
474 static int qemu_powerdown_requested(void)
476 int r
= powerdown_requested
;
477 powerdown_requested
= 0;
481 static int qemu_debug_requested(void)
483 int r
= debug_requested
;
489 * Reset the VM. Issue an event unless @reason is SHUTDOWN_CAUSE_NONE.
491 void qemu_system_reset(ShutdownCause reason
)
495 mc
= current_machine
? MACHINE_GET_CLASS(current_machine
) : NULL
;
497 cpu_synchronize_all_states();
499 if (mc
&& mc
->reset
) {
500 mc
->reset(current_machine
, reason
);
502 qemu_devices_reset(reason
);
505 case SHUTDOWN_CAUSE_NONE
:
506 case SHUTDOWN_CAUSE_SUBSYSTEM_RESET
:
507 case SHUTDOWN_CAUSE_SNAPSHOT_LOAD
:
510 qapi_event_send_reset(shutdown_caused_by_guest(reason
), reason
);
512 cpu_synchronize_all_post_reset();
513 vm_set_suspended(false);
517 * Wake the VM after suspend.
519 static void qemu_system_wakeup(void)
523 mc
= current_machine
? MACHINE_GET_CLASS(current_machine
) : NULL
;
525 if (mc
&& mc
->wakeup
) {
526 mc
->wakeup(current_machine
);
530 void qemu_system_guest_panicked(GuestPanicInformation
*info
)
532 qemu_log_mask(LOG_GUEST_ERROR
, "Guest crashed");
535 current_cpu
->crash_occurred
= true;
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.
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
);
552 qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_RUN
, 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",
568 S390CrashReason_str(info
->u
.s390
.reason
),
569 info
->u
.s390
.psw_mask
,
570 info
->u
.s390
.psw_addr
);
572 qapi_free_GuestPanicInformation(info
);
576 void qemu_system_guest_crashloaded(GuestPanicInformation
*info
)
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
);
583 void qemu_system_reset_request(ShutdownCause reason
)
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
;
592 reset_requested
= reason
;
598 static void qemu_system_suspend(void)
601 notifier_list_notify(&suspend_notifiers
, NULL
);
602 runstate_set(RUN_STATE_SUSPENDED
);
603 qapi_event_send_suspend();
606 void qemu_system_suspend_request(void)
608 if (runstate_check(RUN_STATE_SUSPENDED
)) {
611 suspend_requested
= 1;
616 void qemu_register_suspend_notifier(Notifier
*notifier
)
618 notifier_list_add(&suspend_notifiers
, notifier
);
621 void qemu_system_wakeup_request(WakeupReason reason
, Error
**errp
)
623 trace_system_wakeup_request(reason
);
625 if (!runstate_check(RUN_STATE_SUSPENDED
)) {
627 "Unable to wake up: guest is not in suspended state");
630 if (!(wakeup_reason_mask
& (1 << reason
))) {
633 runstate_set(RUN_STATE_RUNNING
);
634 wakeup_reason
= reason
;
638 void qemu_system_wakeup_enable(WakeupReason reason
, bool enabled
)
641 wakeup_reason_mask
|= (1 << reason
);
643 wakeup_reason_mask
&= ~(1 << reason
);
647 void qemu_register_wakeup_notifier(Notifier
*notifier
)
649 notifier_list_add(&wakeup_notifiers
, notifier
);
652 static bool wakeup_suspend_enabled
;
654 void qemu_register_wakeup_support(void)
656 wakeup_suspend_enabled
= true;
659 bool qemu_wakeup_suspend_enabled(void)
661 return wakeup_suspend_enabled
;
664 void qemu_system_killed(int signal
, pid_t pid
)
666 shutdown_signal
= signal
;
668 shutdown_action
= SHUTDOWN_ACTION_POWEROFF
;
670 /* Cannot call qemu_system_shutdown_request directly because
671 * we are in a signal handler.
673 shutdown_requested
= SHUTDOWN_CAUSE_HOST_SIGNAL
;
677 void qemu_system_shutdown_request_with_code(ShutdownCause reason
,
680 shutdown_exit_code
= exit_code
;
681 qemu_system_shutdown_request(reason
);
684 void qemu_system_shutdown_request(ShutdownCause reason
)
686 trace_qemu_system_shutdown_request(reason
);
687 replay_shutdown_request(reason
);
688 shutdown_requested
= reason
;
692 static void qemu_system_powerdown(void)
694 qapi_event_send_powerdown();
695 notifier_list_notify(&powerdown_notifiers
, NULL
);
698 static void qemu_system_shutdown(ShutdownCause cause
)
700 qapi_event_send_shutdown(shutdown_caused_by_guest(cause
), cause
);
701 notifier_list_notify(&shutdown_notifiers
, &cause
);
704 void qemu_system_powerdown_request(void)
706 trace_qemu_system_powerdown_request();
707 powerdown_requested
= 1;
711 void qemu_register_powerdown_notifier(Notifier
*notifier
)
713 notifier_list_add(&powerdown_notifiers
, notifier
);
716 void qemu_register_shutdown_notifier(Notifier
*notifier
)
718 notifier_list_add(&shutdown_notifiers
, notifier
);
721 void qemu_system_debug_request(void)
727 static bool main_loop_should_exit(int *status
)
730 ShutdownCause request
;
732 if (qemu_debug_requested()) {
733 vm_stop(RUN_STATE_DEBUG
);
735 if (qemu_suspend_requested()) {
736 qemu_system_suspend();
738 request
= qemu_shutdown_requested();
741 qemu_system_shutdown(request
);
742 if (shutdown_action
== SHUTDOWN_ACTION_PAUSE
) {
743 vm_stop(RUN_STATE_SHUTDOWN
);
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
;
754 request
= qemu_reset_requested();
757 qemu_system_reset(request
);
760 * runstate can change in pause_all_vcpus()
761 * as iothread mutex is unlocked
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
);
769 if (qemu_wakeup_requested()) {
771 qemu_system_wakeup();
772 notifier_list_notify(&wakeup_notifiers
, &wakeup_reason
);
773 wakeup_reason
= QEMU_WAKEUP_REASON_NONE
;
775 qapi_event_send_wakeup();
777 if (qemu_powerdown_requested()) {
778 qemu_system_powerdown();
780 if (qemu_vmstop_requested(&r
)) {
786 int qemu_main_loop(void)
788 int status
= EXIT_SUCCESS
;
790 while (!main_loop_should_exit(&status
)) {
791 main_loop_wait(false);
797 void qemu_add_exit_notifier(Notifier
*notify
)
799 notifier_list_add(&exit_notifiers
, notify
);
802 void qemu_remove_exit_notifier(Notifier
*notify
)
804 notifier_remove(notify
);
807 static void qemu_run_exit_notifiers(void)
809 notifier_list_notify(&exit_notifiers
, NULL
);
812 void qemu_init_subsystems(void)
816 os_set_line_buffering();
818 module_call_init(MODULE_INIT_TRACE
);
820 qemu_init_cpu_list();
821 qemu_init_cpu_loop();
824 atexit(qemu_run_exit_notifiers
);
826 module_call_init(MODULE_INIT_QOM
);
827 module_call_init(MODULE_INIT_MIGRATION
);
830 precopy_infrastructure_init();
831 postcopy_infrastructure_init();
832 monitor_init_globals();
834 if (qcrypto_init(&err
) < 0) {
835 error_reportf_err(err
, "cannot initialize crypto: ");
839 os_setup_early_signal_handling();
841 bdrv_init_with_whitelist();
846 void qemu_cleanup(int status
)
851 * cleaning up the migration object cancels any existing migration
852 * try to do this early so that it also stops using devices.
854 migration_shutdown();
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().
865 /* No more vcpu or device emulation activity beyond this point */
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.
878 bdrv_drain_all_begin();
879 job_cancel_sync_all();
882 /* vhost-user must be cleaned up before chardevs. */
888 user_creatable_cleanup();
889 /* TODO: unref root container, check all devices are ok */