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