1 /*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
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 "monitor/monitor.h"
27 #include "qemu/coroutine-tls.h"
28 #include "qapi/error.h"
29 #include "qapi/qapi-commands-machine.h"
30 #include "qapi/qapi-commands-misc.h"
31 #include "qapi/qapi-events-run-state.h"
32 #include "qapi/qmp/qerror.h"
33 #include "exec/gdbstub.h"
34 #include "sysemu/hw_accel.h"
35 #include "exec/cpu-common.h"
36 #include "qemu/thread.h"
37 #include "qemu/main-loop.h"
38 #include "qemu/plugin.h"
39 #include "sysemu/cpus.h"
40 #include "qemu/guest-random.h"
41 #include "hw/nmi.h"
42 #include "sysemu/replay.h"
43 #include "sysemu/runstate.h"
44 #include "sysemu/cpu-timers.h"
45 #include "sysemu/whpx.h"
46 #include "hw/boards.h"
47 #include "hw/hw.h"
48 #include "trace.h"
49
50 #ifdef CONFIG_LINUX
51
52 #include <sys/prctl.h>
53
54 #ifndef PR_MCE_KILL
55 #define PR_MCE_KILL 33
56 #endif
57
58 #ifndef PR_MCE_KILL_SET
59 #define PR_MCE_KILL_SET 1
60 #endif
61
62 #ifndef PR_MCE_KILL_EARLY
63 #define PR_MCE_KILL_EARLY 1
64 #endif
65
66 #endif /* CONFIG_LINUX */
67
68 static QemuMutex qemu_global_mutex;
69
70 /*
71 * The chosen accelerator is supposed to register this.
72 */
73 static const AccelOpsClass *cpus_accel;
74
cpu_is_stopped(CPUState * cpu)75 bool cpu_is_stopped(CPUState *cpu)
76 {
77 return cpu->stopped || !runstate_is_running();
78 }
79
cpu_work_list_empty(CPUState * cpu)80 bool cpu_work_list_empty(CPUState *cpu)
81 {
82 return QSIMPLEQ_EMPTY_ATOMIC(&cpu->work_list);
83 }
84
cpu_thread_is_idle(CPUState * cpu)85 bool cpu_thread_is_idle(CPUState *cpu)
86 {
87 if (cpu->stop || !cpu_work_list_empty(cpu)) {
88 return false;
89 }
90 if (cpu_is_stopped(cpu)) {
91 return true;
92 }
93 if (!cpu->halted || cpu_has_work(cpu)) {
94 return false;
95 }
96 if (cpus_accel->cpu_thread_is_idle) {
97 return cpus_accel->cpu_thread_is_idle(cpu);
98 }
99 return true;
100 }
101
all_cpu_threads_idle(void)102 bool all_cpu_threads_idle(void)
103 {
104 CPUState *cpu;
105
106 CPU_FOREACH(cpu) {
107 if (!cpu_thread_is_idle(cpu)) {
108 return false;
109 }
110 }
111 return true;
112 }
113
114 /***********************************************************/
hw_error(const char * fmt,...)115 void hw_error(const char *fmt, ...)
116 {
117 va_list ap;
118 CPUState *cpu;
119
120 va_start(ap, fmt);
121 fprintf(stderr, "qemu: hardware error: ");
122 vfprintf(stderr, fmt, ap);
123 fprintf(stderr, "\n");
124 CPU_FOREACH(cpu) {
125 fprintf(stderr, "CPU #%d:\n", cpu->cpu_index);
126 cpu_dump_state(cpu, stderr, CPU_DUMP_FPU);
127 }
128 va_end(ap);
129 abort();
130 }
131
cpu_synchronize_all_states(void)132 void cpu_synchronize_all_states(void)
133 {
134 CPUState *cpu;
135
136 CPU_FOREACH(cpu) {
137 cpu_synchronize_state(cpu);
138 }
139 }
140
cpu_synchronize_all_post_reset(void)141 void cpu_synchronize_all_post_reset(void)
142 {
143 CPUState *cpu;
144
145 CPU_FOREACH(cpu) {
146 cpu_synchronize_post_reset(cpu);
147 }
148 }
149
cpu_synchronize_all_post_init(void)150 void cpu_synchronize_all_post_init(void)
151 {
152 CPUState *cpu;
153
154 CPU_FOREACH(cpu) {
155 cpu_synchronize_post_init(cpu);
156 }
157 }
158
cpu_synchronize_all_pre_loadvm(void)159 void cpu_synchronize_all_pre_loadvm(void)
160 {
161 CPUState *cpu;
162
163 CPU_FOREACH(cpu) {
164 cpu_synchronize_pre_loadvm(cpu);
165 }
166 }
167
cpu_synchronize_state(CPUState * cpu)168 void cpu_synchronize_state(CPUState *cpu)
169 {
170 if (cpus_accel->synchronize_state) {
171 cpus_accel->synchronize_state(cpu);
172 }
173 }
174
cpu_synchronize_post_reset(CPUState * cpu)175 void cpu_synchronize_post_reset(CPUState *cpu)
176 {
177 if (cpus_accel->synchronize_post_reset) {
178 cpus_accel->synchronize_post_reset(cpu);
179 }
180 }
181
cpu_synchronize_post_init(CPUState * cpu)182 void cpu_synchronize_post_init(CPUState *cpu)
183 {
184 if (cpus_accel->synchronize_post_init) {
185 cpus_accel->synchronize_post_init(cpu);
186 }
187 }
188
cpu_synchronize_pre_loadvm(CPUState * cpu)189 void cpu_synchronize_pre_loadvm(CPUState *cpu)
190 {
191 if (cpus_accel->synchronize_pre_loadvm) {
192 cpus_accel->synchronize_pre_loadvm(cpu);
193 }
194 }
195
cpus_are_resettable(void)196 bool cpus_are_resettable(void)
197 {
198 if (cpus_accel->cpus_are_resettable) {
199 return cpus_accel->cpus_are_resettable();
200 }
201 return true;
202 }
203
cpu_exec_reset_hold(CPUState * cpu)204 void cpu_exec_reset_hold(CPUState *cpu)
205 {
206 if (cpus_accel->cpu_reset_hold) {
207 cpus_accel->cpu_reset_hold(cpu);
208 }
209 }
210
cpus_get_virtual_clock(void)211 int64_t cpus_get_virtual_clock(void)
212 {
213 /*
214 * XXX
215 *
216 * need to check that cpus_accel is not NULL, because qcow2 calls
217 * qemu_get_clock_ns(CLOCK_VIRTUAL) without any accel initialized and
218 * with ticks disabled in some io-tests:
219 * 030 040 041 060 099 120 127 140 156 161 172 181 191 192 195 203 229 249 256 267
220 *
221 * is this expected?
222 *
223 * XXX
224 */
225 if (cpus_accel && cpus_accel->get_virtual_clock) {
226 return cpus_accel->get_virtual_clock();
227 }
228 return cpu_get_clock();
229 }
230
231 /*
232 * return the time elapsed in VM between vm_start and vm_stop. Unless
233 * icount is active, cpus_get_elapsed_ticks() uses units of the host CPU cycle
234 * counter.
235 */
cpus_get_elapsed_ticks(void)236 int64_t cpus_get_elapsed_ticks(void)
237 {
238 if (cpus_accel->get_elapsed_ticks) {
239 return cpus_accel->get_elapsed_ticks();
240 }
241 return cpu_get_ticks();
242 }
243
generic_handle_interrupt(CPUState * cpu,int mask)244 static void generic_handle_interrupt(CPUState *cpu, int mask)
245 {
246 cpu->interrupt_request |= mask;
247
248 if (!qemu_cpu_is_self(cpu)) {
249 qemu_cpu_kick(cpu);
250 }
251 }
252
cpu_interrupt(CPUState * cpu,int mask)253 void cpu_interrupt(CPUState *cpu, int mask)
254 {
255 if (cpus_accel->handle_interrupt) {
256 cpus_accel->handle_interrupt(cpu, mask);
257 } else {
258 generic_handle_interrupt(cpu, mask);
259 }
260 }
261
do_vm_stop(RunState state,bool send_stop)262 static int do_vm_stop(RunState state, bool send_stop)
263 {
264 int ret = 0;
265
266 if (runstate_is_running()) {
267 runstate_set(state);
268 cpu_disable_ticks();
269 pause_all_vcpus();
270 vm_state_notify(0, state);
271 if (send_stop) {
272 qapi_event_send_stop();
273 }
274 }
275
276 bdrv_drain_all();
277 ret = bdrv_flush_all();
278 trace_vm_stop_flush_all(ret);
279
280 return ret;
281 }
282
283 /* Special vm_stop() variant for terminating the process. Historically clients
284 * did not expect a QMP STOP event and so we need to retain compatibility.
285 */
vm_shutdown(void)286 int vm_shutdown(void)
287 {
288 return do_vm_stop(RUN_STATE_SHUTDOWN, false);
289 }
290
cpu_can_run(CPUState * cpu)291 bool cpu_can_run(CPUState *cpu)
292 {
293 if (cpu->stop) {
294 return false;
295 }
296 if (cpu_is_stopped(cpu)) {
297 return false;
298 }
299 return true;
300 }
301
cpu_handle_guest_debug(CPUState * cpu)302 void cpu_handle_guest_debug(CPUState *cpu)
303 {
304 if (replay_running_debug()) {
305 if (!cpu->singlestep_enabled) {
306 /*
307 * Report about the breakpoint and
308 * make a single step to skip it
309 */
310 replay_breakpoint();
311 cpu_single_step(cpu, SSTEP_ENABLE);
312 } else {
313 cpu_single_step(cpu, 0);
314 }
315 } else {
316 gdb_set_stop_cpu(cpu);
317 qemu_system_debug_request();
318 cpu->stopped = true;
319 }
320 }
321
322 #ifdef CONFIG_LINUX
sigbus_reraise(void)323 static void sigbus_reraise(void)
324 {
325 sigset_t set;
326 struct sigaction action;
327
328 memset(&action, 0, sizeof(action));
329 action.sa_handler = SIG_DFL;
330 if (!sigaction(SIGBUS, &action, NULL)) {
331 raise(SIGBUS);
332 sigemptyset(&set);
333 sigaddset(&set, SIGBUS);
334 pthread_sigmask(SIG_UNBLOCK, &set, NULL);
335 }
336 perror("Failed to re-raise SIGBUS!");
337 abort();
338 }
339
sigbus_handler(int n,siginfo_t * siginfo,void * ctx)340 static void sigbus_handler(int n, siginfo_t *siginfo, void *ctx)
341 {
342 if (siginfo->si_code != BUS_MCEERR_AO && siginfo->si_code != BUS_MCEERR_AR) {
343 sigbus_reraise();
344 }
345
346 if (current_cpu) {
347 /* Called asynchronously in VCPU thread. */
348 if (kvm_on_sigbus_vcpu(current_cpu, siginfo->si_code, siginfo->si_addr)) {
349 sigbus_reraise();
350 }
351 } else {
352 /* Called synchronously (via signalfd) in main thread. */
353 if (kvm_on_sigbus(siginfo->si_code, siginfo->si_addr)) {
354 sigbus_reraise();
355 }
356 }
357 }
358
qemu_init_sigbus(void)359 static void qemu_init_sigbus(void)
360 {
361 struct sigaction action;
362
363 /*
364 * ALERT: when modifying this, take care that SIGBUS forwarding in
365 * qemu_prealloc_mem() will continue working as expected.
366 */
367 memset(&action, 0, sizeof(action));
368 action.sa_flags = SA_SIGINFO;
369 action.sa_sigaction = sigbus_handler;
370 sigaction(SIGBUS, &action, NULL);
371
372 prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, 0, 0);
373 }
374 #else /* !CONFIG_LINUX */
qemu_init_sigbus(void)375 static void qemu_init_sigbus(void)
376 {
377 }
378 #endif /* !CONFIG_LINUX */
379
380 static QemuThread io_thread;
381
382 /* cpu creation */
383 static QemuCond qemu_cpu_cond;
384 /* system init */
385 static QemuCond qemu_pause_cond;
386
qemu_init_cpu_loop(void)387 void qemu_init_cpu_loop(void)
388 {
389 qemu_init_sigbus();
390 qemu_cond_init(&qemu_cpu_cond);
391 qemu_cond_init(&qemu_pause_cond);
392 qemu_mutex_init(&qemu_global_mutex);
393
394 qemu_thread_get_self(&io_thread);
395 }
396
run_on_cpu(CPUState * cpu,run_on_cpu_func func,run_on_cpu_data data)397 void run_on_cpu(CPUState *cpu, run_on_cpu_func func, run_on_cpu_data data)
398 {
399 do_run_on_cpu(cpu, func, data, &qemu_global_mutex);
400 }
401
qemu_cpu_stop(CPUState * cpu,bool exit)402 static void qemu_cpu_stop(CPUState *cpu, bool exit)
403 {
404 g_assert(qemu_cpu_is_self(cpu));
405 cpu->stop = false;
406 cpu->stopped = true;
407 if (exit) {
408 cpu_exit(cpu);
409 }
410 qemu_cond_broadcast(&qemu_pause_cond);
411 }
412
qemu_wait_io_event_common(CPUState * cpu)413 void qemu_wait_io_event_common(CPUState *cpu)
414 {
415 qatomic_set_mb(&cpu->thread_kicked, false);
416 if (cpu->stop) {
417 qemu_cpu_stop(cpu, false);
418 }
419 process_queued_cpu_work(cpu);
420 }
421
qemu_wait_io_event(CPUState * cpu)422 void qemu_wait_io_event(CPUState *cpu)
423 {
424 bool slept = false;
425
426 while (cpu_thread_is_idle(cpu)) {
427 if (!slept) {
428 slept = true;
429 qemu_plugin_vcpu_idle_cb(cpu);
430 }
431 qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
432 }
433 if (slept) {
434 qemu_plugin_vcpu_resume_cb(cpu);
435 }
436
437 qemu_wait_io_event_common(cpu);
438 }
439
cpus_kick_thread(CPUState * cpu)440 void cpus_kick_thread(CPUState *cpu)
441 {
442 if (cpu->thread_kicked) {
443 return;
444 }
445 cpu->thread_kicked = true;
446
447 #ifndef _WIN32
448 int err = pthread_kill(cpu->thread->thread, SIG_IPI);
449 if (err && err != ESRCH) {
450 fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
451 exit(1);
452 }
453 #else
454 qemu_sem_post(&cpu->sem);
455 #endif
456 }
457
qemu_cpu_kick(CPUState * cpu)458 void qemu_cpu_kick(CPUState *cpu)
459 {
460 qemu_cond_broadcast(cpu->halt_cond);
461 if (cpus_accel->kick_vcpu_thread) {
462 cpus_accel->kick_vcpu_thread(cpu);
463 } else { /* default */
464 cpus_kick_thread(cpu);
465 }
466 }
467
qemu_cpu_kick_self(void)468 void qemu_cpu_kick_self(void)
469 {
470 assert(current_cpu);
471 cpus_kick_thread(current_cpu);
472 }
473
qemu_cpu_is_self(CPUState * cpu)474 bool qemu_cpu_is_self(CPUState *cpu)
475 {
476 return qemu_thread_is_self(cpu->thread);
477 }
478
qemu_in_vcpu_thread(void)479 bool qemu_in_vcpu_thread(void)
480 {
481 return current_cpu && qemu_cpu_is_self(current_cpu);
482 }
483
QEMU_DEFINE_STATIC_CO_TLS(bool,iothread_locked)484 QEMU_DEFINE_STATIC_CO_TLS(bool, iothread_locked)
485
486 bool qemu_mutex_iothread_locked(void)
487 {
488 return get_iothread_locked();
489 }
490
qemu_in_main_thread(void)491 bool qemu_in_main_thread(void)
492 {
493 return qemu_mutex_iothread_locked();
494 }
495
496 /*
497 * The BQL is taken from so many places that it is worth profiling the
498 * callers directly, instead of funneling them all through a single function.
499 */
qemu_mutex_lock_iothread_impl(const char * file,int line)500 void qemu_mutex_lock_iothread_impl(const char *file, int line)
501 {
502 QemuMutexLockFunc bql_lock = qatomic_read(&qemu_bql_mutex_lock_func);
503
504 g_assert(!qemu_mutex_iothread_locked());
505 bql_lock(&qemu_global_mutex, file, line);
506 set_iothread_locked(true);
507 }
508
qemu_mutex_unlock_iothread(void)509 void qemu_mutex_unlock_iothread(void)
510 {
511 g_assert(qemu_mutex_iothread_locked());
512 set_iothread_locked(false);
513 qemu_mutex_unlock(&qemu_global_mutex);
514 }
515
qemu_cond_wait_iothread(QemuCond * cond)516 void qemu_cond_wait_iothread(QemuCond *cond)
517 {
518 qemu_cond_wait(cond, &qemu_global_mutex);
519 }
520
qemu_cond_timedwait_iothread(QemuCond * cond,int ms)521 void qemu_cond_timedwait_iothread(QemuCond *cond, int ms)
522 {
523 qemu_cond_timedwait(cond, &qemu_global_mutex, ms);
524 }
525
526 /* signal CPU creation */
cpu_thread_signal_created(CPUState * cpu)527 void cpu_thread_signal_created(CPUState *cpu)
528 {
529 cpu->created = true;
530 qemu_cond_signal(&qemu_cpu_cond);
531 }
532
533 /* signal CPU destruction */
cpu_thread_signal_destroyed(CPUState * cpu)534 void cpu_thread_signal_destroyed(CPUState *cpu)
535 {
536 cpu->created = false;
537 qemu_cond_signal(&qemu_cpu_cond);
538 }
539
540
all_vcpus_paused(void)541 static bool all_vcpus_paused(void)
542 {
543 CPUState *cpu;
544
545 CPU_FOREACH(cpu) {
546 if (!cpu->stopped) {
547 return false;
548 }
549 }
550
551 return true;
552 }
553
pause_all_vcpus(void)554 void pause_all_vcpus(void)
555 {
556 CPUState *cpu;
557
558 qemu_clock_enable(QEMU_CLOCK_VIRTUAL, false);
559 CPU_FOREACH(cpu) {
560 if (qemu_cpu_is_self(cpu)) {
561 qemu_cpu_stop(cpu, true);
562 } else {
563 cpu->stop = true;
564 qemu_cpu_kick(cpu);
565 }
566 }
567
568 /* We need to drop the replay_lock so any vCPU threads woken up
569 * can finish their replay tasks
570 */
571 replay_mutex_unlock();
572
573 while (!all_vcpus_paused()) {
574 qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
575 CPU_FOREACH(cpu) {
576 qemu_cpu_kick(cpu);
577 }
578 }
579
580 qemu_mutex_unlock_iothread();
581 replay_mutex_lock();
582 qemu_mutex_lock_iothread();
583 }
584
cpu_resume(CPUState * cpu)585 void cpu_resume(CPUState *cpu)
586 {
587 cpu->stop = false;
588 cpu->stopped = false;
589 qemu_cpu_kick(cpu);
590 }
591
resume_all_vcpus(void)592 void resume_all_vcpus(void)
593 {
594 CPUState *cpu;
595
596 if (!runstate_is_running()) {
597 return;
598 }
599
600 qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
601 CPU_FOREACH(cpu) {
602 cpu_resume(cpu);
603 }
604 }
605
cpu_remove_sync(CPUState * cpu)606 void cpu_remove_sync(CPUState *cpu)
607 {
608 cpu->stop = true;
609 cpu->unplug = true;
610 qemu_cpu_kick(cpu);
611 qemu_mutex_unlock_iothread();
612 qemu_thread_join(cpu->thread);
613 qemu_mutex_lock_iothread();
614 }
615
cpus_register_accel(const AccelOpsClass * ops)616 void cpus_register_accel(const AccelOpsClass *ops)
617 {
618 assert(ops != NULL);
619 assert(ops->create_vcpu_thread != NULL); /* mandatory */
620 cpus_accel = ops;
621 }
622
cpus_get_accel(void)623 const AccelOpsClass *cpus_get_accel(void)
624 {
625 /* broken if we call this early */
626 assert(cpus_accel);
627 return cpus_accel;
628 }
629
qemu_init_vcpu(CPUState * cpu)630 void qemu_init_vcpu(CPUState *cpu)
631 {
632 MachineState *ms = MACHINE(qdev_get_machine());
633
634 cpu->nr_cores = machine_topo_get_cores_per_socket(ms);
635 cpu->nr_threads = ms->smp.threads;
636 cpu->stopped = true;
637 cpu->random_seed = qemu_guest_random_seed_thread_part1();
638
639 if (!cpu->as) {
640 /* If the target cpu hasn't set up any address spaces itself,
641 * give it the default one.
642 */
643 cpu->num_ases = 1;
644 cpu_address_space_init(cpu, 0, "cpu-memory", cpu->memory);
645 }
646
647 /* accelerators all implement the AccelOpsClass */
648 g_assert(cpus_accel != NULL && cpus_accel->create_vcpu_thread != NULL);
649 cpus_accel->create_vcpu_thread(cpu);
650
651 while (!cpu->created) {
652 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
653 }
654 }
655
cpu_stop_current(void)656 void cpu_stop_current(void)
657 {
658 if (current_cpu) {
659 current_cpu->stop = true;
660 cpu_exit(current_cpu);
661 }
662 }
663
vm_stop(RunState state)664 int vm_stop(RunState state)
665 {
666 if (qemu_in_vcpu_thread()) {
667 qemu_system_vmstop_request_prepare();
668 qemu_system_vmstop_request(state);
669 /*
670 * FIXME: should not return to device code in case
671 * vm_stop() has been requested.
672 */
673 cpu_stop_current();
674 return 0;
675 }
676
677 return do_vm_stop(state, true);
678 }
679
680 /**
681 * Prepare for (re)starting the VM.
682 * Returns -1 if the vCPUs are not to be restarted (e.g. if they are already
683 * running or in case of an error condition), 0 otherwise.
684 */
vm_prepare_start(bool step_pending)685 int vm_prepare_start(bool step_pending)
686 {
687 RunState requested;
688
689 qemu_vmstop_requested(&requested);
690 if (runstate_is_running() && requested == RUN_STATE__MAX) {
691 return -1;
692 }
693
694 /* Ensure that a STOP/RESUME pair of events is emitted if a
695 * vmstop request was pending. The BLOCK_IO_ERROR event, for
696 * example, according to documentation is always followed by
697 * the STOP event.
698 */
699 if (runstate_is_running()) {
700 qapi_event_send_stop();
701 qapi_event_send_resume();
702 return -1;
703 }
704
705 /*
706 * WHPX accelerator needs to know whether we are going to step
707 * any CPUs, before starting the first one.
708 */
709 if (cpus_accel->synchronize_pre_resume) {
710 cpus_accel->synchronize_pre_resume(step_pending);
711 }
712
713 /* We are sending this now, but the CPUs will be resumed shortly later */
714 qapi_event_send_resume();
715
716 cpu_enable_ticks();
717 runstate_set(RUN_STATE_RUNNING);
718 vm_state_notify(1, RUN_STATE_RUNNING);
719 return 0;
720 }
721
vm_start(void)722 void vm_start(void)
723 {
724 if (!vm_prepare_start(false)) {
725 resume_all_vcpus();
726 }
727 }
728
729 /* does a state transition even if the VM is already stopped,
730 current state is forgotten forever */
vm_stop_force_state(RunState state)731 int vm_stop_force_state(RunState state)
732 {
733 if (runstate_is_running()) {
734 return vm_stop(state);
735 } else {
736 int ret;
737 runstate_set(state);
738
739 bdrv_drain_all();
740 /* Make sure to return an error if the flush in a previous vm_stop()
741 * failed. */
742 ret = bdrv_flush_all();
743 trace_vm_stop_flush_all(ret);
744 return ret;
745 }
746 }
747
qmp_memsave(int64_t addr,int64_t size,const char * filename,bool has_cpu,int64_t cpu_index,Error ** errp)748 void qmp_memsave(int64_t addr, int64_t size, const char *filename,
749 bool has_cpu, int64_t cpu_index, Error **errp)
750 {
751 FILE *f;
752 uint32_t l;
753 CPUState *cpu;
754 uint8_t buf[1024];
755 int64_t orig_addr = addr, orig_size = size;
756
757 if (!has_cpu) {
758 cpu_index = 0;
759 }
760
761 cpu = qemu_get_cpu(cpu_index);
762 if (cpu == NULL) {
763 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
764 "a CPU number");
765 return;
766 }
767
768 f = fopen(filename, "wb");
769 if (!f) {
770 error_setg_file_open(errp, errno, filename);
771 return;
772 }
773
774 while (size != 0) {
775 l = sizeof(buf);
776 if (l > size)
777 l = size;
778 if (cpu_memory_rw_debug(cpu, addr, buf, l, 0) != 0) {
779 error_setg(errp, "Invalid addr 0x%016" PRIx64 "/size %" PRId64
780 " specified", orig_addr, orig_size);
781 goto exit;
782 }
783 if (fwrite(buf, 1, l, f) != l) {
784 error_setg(errp, QERR_IO_ERROR);
785 goto exit;
786 }
787 addr += l;
788 size -= l;
789 }
790
791 exit:
792 fclose(f);
793 }
794
qmp_pmemsave(int64_t addr,int64_t size,const char * filename,Error ** errp)795 void qmp_pmemsave(int64_t addr, int64_t size, const char *filename,
796 Error **errp)
797 {
798 FILE *f;
799 uint32_t l;
800 uint8_t buf[1024];
801
802 f = fopen(filename, "wb");
803 if (!f) {
804 error_setg_file_open(errp, errno, filename);
805 return;
806 }
807
808 while (size != 0) {
809 l = sizeof(buf);
810 if (l > size)
811 l = size;
812 cpu_physical_memory_read(addr, buf, l);
813 if (fwrite(buf, 1, l, f) != l) {
814 error_setg(errp, QERR_IO_ERROR);
815 goto exit;
816 }
817 addr += l;
818 size -= l;
819 }
820
821 exit:
822 fclose(f);
823 }
824
qmp_inject_nmi(Error ** errp)825 void qmp_inject_nmi(Error **errp)
826 {
827 nmi_monitor_handle(monitor_get_cpu_index(monitor_cur()), errp);
828 }
829
830