]>
Commit | Line | Data |
---|---|---|
ba87e434 PB |
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" | |
1895b977 | 28 | #include "block/export.h" |
ba87e434 PB |
29 | #include "chardev/char.h" |
30 | #include "crypto/cipher.h" | |
31 | #include "crypto/init.h" | |
32 | #include "exec/cpu-common.h" | |
c566080c | 33 | #include "gdbstub/syscalls.h" |
ba87e434 PB |
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" | |
93cbd6c9 | 43 | #include "qemu/accel.h" |
ba87e434 PB |
44 | #include "qemu/error-report.h" |
45 | #include "qemu/job.h" | |
bc2fbf93 | 46 | #include "qemu/log.h" |
ba87e434 PB |
47 | #include "qemu/module.h" |
48 | #include "qemu/plugin.h" | |
49 | #include "qemu/sockets.h" | |
533206f0 | 50 | #include "qemu/timer.h" |
ba87e434 PB |
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" | |
e6dba048 | 59 | #include "sysemu/runstate-action.h" |
ba87e434 PB |
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 }, | |
58b10570 | 80 | { RUN_STATE_PRELAUNCH, RUN_STATE_SUSPENDED }, |
ba87e434 PB |
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}, | |
b9ae473d | 112 | { RUN_STATE_PAUSED, RUN_STATE_SUSPENDED}, |
ba87e434 PB |
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 }, | |
a4c6275a VSO |
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 }, | |
ba87e434 PB |
133 | |
134 | { RUN_STATE_RESTORE_VM, RUN_STATE_RUNNING }, | |
135 | { RUN_STATE_RESTORE_VM, RUN_STATE_PRELAUNCH }, | |
58b10570 | 136 | { RUN_STATE_RESTORE_VM, RUN_STATE_SUSPENDED }, |
ba87e434 PB |
137 | |
138 | { RUN_STATE_COLO, RUN_STATE_RUNNING }, | |
669846c5 | 139 | { RUN_STATE_COLO, RUN_STATE_PRELAUNCH }, |
229620d5 | 140 | { RUN_STATE_COLO, RUN_STATE_SHUTDOWN}, |
ba87e434 PB |
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 }, | |
58b10570 | 155 | { RUN_STATE_SAVE_VM, RUN_STATE_SUSPENDED }, |
ba87e434 PB |
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}, | |
b9ae473d | 168 | { RUN_STATE_SUSPENDED, RUN_STATE_PAUSED}, |
58b10570 SS |
169 | { RUN_STATE_SUSPENDED, RUN_STATE_SAVE_VM }, |
170 | { RUN_STATE_SUSPENDED, RUN_STATE_RESTORE_VM }, | |
49a50206 | 171 | { RUN_STATE_SUSPENDED, RUN_STATE_SHUTDOWN }, |
ba87e434 PB |
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 | ||
ba87e434 PB |
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 | ||
242b74eb VSO |
226 | RunState runstate_get(void) |
227 | { | |
228 | return current_run_state; | |
229 | } | |
230 | ||
0a389509 | 231 | bool runstate_is_running(void) |
ba87e434 PB |
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)); | |
93cbd6c9 PM |
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); | |
ba87e434 | 254 | info->running = runstate_is_running(); |
ba87e434 PB |
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; | |
9d3103c8 | 282 | VMChangeStateHandler *prepare_cb; |
ba87e434 PB |
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) | |
9d3103c8 AH |
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) | |
ba87e434 PB |
331 | { |
332 | VMChangeStateEntry *e; | |
333 | VMChangeStateEntry *other; | |
334 | ||
335 | e = g_malloc0(sizeof(*e)); | |
336 | e->cb = cb; | |
9d3103c8 | 337 | e->prepare_cb = prepare_cb; |
ba87e434 PB |
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 | ||
538f0497 | 365 | void vm_state_notify(bool running, RunState state) |
ba87e434 PB |
366 | { |
367 | VMChangeStateEntry *e, *next; | |
368 | ||
369 | trace_vm_state_notify(running, state, RunState_str(state)); | |
370 | ||
371 | if (running) { | |
9d3103c8 AH |
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 | ||
ba87e434 PB |
378 | QTAILQ_FOREACH_SAFE(e, &vm_change_state_head, entries, next) { |
379 | e->cb(e->opaque, running, state); | |
380 | } | |
381 | } else { | |
9d3103c8 AH |
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 | ||
ba87e434 PB |
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; | |
0386f39b | 396 | static int shutdown_exit_code = EXIT_SUCCESS; |
ba87e434 PB |
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) { | |
7966d70f | 500 | mc->reset(current_machine, reason); |
ba87e434 | 501 | } else { |
7966d70f | 502 | qemu_devices_reset(reason); |
ba87e434 | 503 | } |
7966d70f JD |
504 | switch (reason) { |
505 | case SHUTDOWN_CAUSE_NONE: | |
506 | case SHUTDOWN_CAUSE_SUBSYSTEM_RESET: | |
507 | case SHUTDOWN_CAUSE_SNAPSHOT_LOAD: | |
508 | break; | |
509 | default: | |
ba87e434 PB |
510 | qapi_event_send_reset(shutdown_caused_by_guest(reason), reason); |
511 | } | |
512 | cpu_synchronize_all_post_reset(); | |
b9ae473d | 513 | vm_set_suspended(false); |
ba87e434 PB |
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 | } | |
c753e8e7 AJ |
537 | /* |
538 | * TODO: Currently the available panic actions are: none, pause, and | |
c27025e0 | 539 | * shutdown, but in principle debug and reset could be supported as well. |
c753e8e7 AJ |
540 | * Investigate any potential use cases for the unimplemented actions. |
541 | */ | |
c27025e0 PB |
542 | if (panic_action == PANIC_ACTION_PAUSE |
543 | || (panic_action == PANIC_ACTION_SHUTDOWN && shutdown_action == SHUTDOWN_ACTION_PAUSE)) { | |
0ccc2c92 | 544 | qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_PAUSE, info); |
c753e8e7 | 545 | vm_stop(RUN_STATE_GUEST_PANICKED); |
0882caf4 IL |
546 | } else if (panic_action == PANIC_ACTION_SHUTDOWN || |
547 | panic_action == PANIC_ACTION_EXIT_FAILURE) { | |
0ccc2c92 | 548 | qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_POWEROFF, info); |
c753e8e7 | 549 | vm_stop(RUN_STATE_GUEST_PANICKED); |
ba87e434 | 550 | qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_PANIC); |
c753e8e7 | 551 | } else { |
0ccc2c92 | 552 | qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_RUN, info); |
ba87e434 PB |
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"); | |
0ccc2c92 MA |
579 | qapi_event_send_guest_crashloaded(GUEST_PANIC_ACTION_RUN, info); |
580 | qapi_free_GuestPanicInformation(info); | |
ba87e434 PB |
581 | } |
582 | ||
583 | void qemu_system_reset_request(ShutdownCause reason) | |
584 | { | |
e6dba048 AJ |
585 | if (reboot_action == REBOOT_ACTION_SHUTDOWN && |
586 | reason != SHUTDOWN_CAUSE_SUBSYSTEM_RESET) { | |
ba87e434 | 587 | shutdown_requested = reason; |
92a5199b TL |
588 | } else if (!cpus_are_resettable()) { |
589 | error_report("cpus are not resettable, terminating"); | |
590 | shutdown_requested = reason; | |
ba87e434 PB |
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; | |
e6dba048 | 668 | shutdown_action = SHUTDOWN_ACTION_POWEROFF; |
ba87e434 PB |
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 | ||
0386f39b CC |
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 | ||
ba87e434 PB |
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 | ||
0882caf4 | 727 | static bool main_loop_should_exit(int *status) |
ba87e434 PB |
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); | |
e6dba048 | 742 | if (shutdown_action == SHUTDOWN_ACTION_PAUSE) { |
ba87e434 PB |
743 | vm_stop(RUN_STATE_SHUTDOWN); |
744 | } else { | |
0386f39b CC |
745 | if (shutdown_exit_code != EXIT_SUCCESS) { |
746 | *status = shutdown_exit_code; | |
747 | } else if (request == SHUTDOWN_CAUSE_GUEST_PANIC && | |
0882caf4 IL |
748 | panic_action == PANIC_ACTION_EXIT_FAILURE) { |
749 | *status = EXIT_FAILURE; | |
750 | } | |
ba87e434 PB |
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 | ||
0882caf4 | 786 | int qemu_main_loop(void) |
ba87e434 | 787 | { |
0882caf4 | 788 | int status = EXIT_SUCCESS; |
0882caf4 IL |
789 | |
790 | while (!main_loop_should_exit(&status)) { | |
ba87e434 | 791 | main_loop_wait(false); |
ba87e434 | 792 | } |
0882caf4 IL |
793 | |
794 | return status; | |
ba87e434 PB |
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 | { | |
6e1da3d3 | 814 | Error *err = NULL; |
ba87e434 PB |
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(); | |
195801d7 | 822 | bql_lock(); |
ba87e434 PB |
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 | ||
66bbe3e9 | 846 | void qemu_cleanup(int status) |
ba87e434 | 847 | { |
66bbe3e9 | 848 | gdb_exit(status); |
ba87e434 PB |
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 | ||
1895b977 SL |
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 | ||
ca2a5e63 FE |
864 | |
865 | /* No more vcpu or device emulation activity beyond this point */ | |
866 | vm_shutdown(); | |
867 | replay_finish(); | |
868 | ||
ba87e434 PB |
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. | |
ca2a5e63 FE |
873 | * Begin the drained section after vm_shutdown() to avoid requests being |
874 | * stuck in the BlockBackend's request queue. | |
ba87e434 PB |
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(); | |
ba87e434 PB |
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 | } |