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