cpus: Fix pausing TCG CPUs while in vCPU thread
[qemu.git] / 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 /* Needed early for CONFIG_BSD etc. */
26 #include "config-host.h"
27
28 #include "monitor/monitor.h"
29 #include "sysemu/sysemu.h"
30 #include "exec/gdbstub.h"
31 #include "sysemu/dma.h"
32 #include "sysemu/kvm.h"
33 #include "qmp-commands.h"
34
35 #include "qemu/thread.h"
36 #include "sysemu/cpus.h"
37 #include "sysemu/qtest.h"
38 #include "qemu/main-loop.h"
39 #include "qemu/bitmap.h"
40
41 #ifndef _WIN32
42 #include "qemu/compatfd.h"
43 #endif
44
45 #ifdef CONFIG_LINUX
46
47 #include <sys/prctl.h>
48
49 #ifndef PR_MCE_KILL
50 #define PR_MCE_KILL 33
51 #endif
52
53 #ifndef PR_MCE_KILL_SET
54 #define PR_MCE_KILL_SET 1
55 #endif
56
57 #ifndef PR_MCE_KILL_EARLY
58 #define PR_MCE_KILL_EARLY 1
59 #endif
60
61 #endif /* CONFIG_LINUX */
62
63 static CPUArchState *next_cpu;
64
65 static bool cpu_thread_is_idle(CPUArchState *env)
66 {
67 CPUState *cpu = ENV_GET_CPU(env);
68
69 if (cpu->stop || cpu->queued_work_first) {
70 return false;
71 }
72 if (cpu->stopped || !runstate_is_running()) {
73 return true;
74 }
75 if (!cpu->halted || qemu_cpu_has_work(cpu) ||
76 kvm_async_interrupts_enabled()) {
77 return false;
78 }
79 return true;
80 }
81
82 static bool all_cpu_threads_idle(void)
83 {
84 CPUArchState *env;
85
86 for (env = first_cpu; env != NULL; env = env->next_cpu) {
87 if (!cpu_thread_is_idle(env)) {
88 return false;
89 }
90 }
91 return true;
92 }
93
94 /***********************************************************/
95 /* guest cycle counter */
96
97 /* Conversion factor from emulated instructions to virtual clock ticks. */
98 static int icount_time_shift;
99 /* Arbitrarily pick 1MIPS as the minimum allowable speed. */
100 #define MAX_ICOUNT_SHIFT 10
101 /* Compensate for varying guest execution speed. */
102 static int64_t qemu_icount_bias;
103 static QEMUTimer *icount_rt_timer;
104 static QEMUTimer *icount_vm_timer;
105 static QEMUTimer *icount_warp_timer;
106 static int64_t vm_clock_warp_start;
107 static int64_t qemu_icount;
108
109 typedef struct TimersState {
110 int64_t cpu_ticks_prev;
111 int64_t cpu_ticks_offset;
112 int64_t cpu_clock_offset;
113 int32_t cpu_ticks_enabled;
114 int64_t dummy;
115 } TimersState;
116
117 TimersState timers_state;
118
119 /* Return the virtual CPU time, based on the instruction counter. */
120 int64_t cpu_get_icount(void)
121 {
122 int64_t icount;
123 CPUArchState *env = cpu_single_env;
124
125 icount = qemu_icount;
126 if (env) {
127 if (!can_do_io(env)) {
128 fprintf(stderr, "Bad clock read\n");
129 }
130 icount -= (env->icount_decr.u16.low + env->icount_extra);
131 }
132 return qemu_icount_bias + (icount << icount_time_shift);
133 }
134
135 /* return the host CPU cycle counter and handle stop/restart */
136 int64_t cpu_get_ticks(void)
137 {
138 if (use_icount) {
139 return cpu_get_icount();
140 }
141 if (!timers_state.cpu_ticks_enabled) {
142 return timers_state.cpu_ticks_offset;
143 } else {
144 int64_t ticks;
145 ticks = cpu_get_real_ticks();
146 if (timers_state.cpu_ticks_prev > ticks) {
147 /* Note: non increasing ticks may happen if the host uses
148 software suspend */
149 timers_state.cpu_ticks_offset += timers_state.cpu_ticks_prev - ticks;
150 }
151 timers_state.cpu_ticks_prev = ticks;
152 return ticks + timers_state.cpu_ticks_offset;
153 }
154 }
155
156 /* return the host CPU monotonic timer and handle stop/restart */
157 int64_t cpu_get_clock(void)
158 {
159 int64_t ti;
160 if (!timers_state.cpu_ticks_enabled) {
161 return timers_state.cpu_clock_offset;
162 } else {
163 ti = get_clock();
164 return ti + timers_state.cpu_clock_offset;
165 }
166 }
167
168 /* enable cpu_get_ticks() */
169 void cpu_enable_ticks(void)
170 {
171 if (!timers_state.cpu_ticks_enabled) {
172 timers_state.cpu_ticks_offset -= cpu_get_real_ticks();
173 timers_state.cpu_clock_offset -= get_clock();
174 timers_state.cpu_ticks_enabled = 1;
175 }
176 }
177
178 /* disable cpu_get_ticks() : the clock is stopped. You must not call
179 cpu_get_ticks() after that. */
180 void cpu_disable_ticks(void)
181 {
182 if (timers_state.cpu_ticks_enabled) {
183 timers_state.cpu_ticks_offset = cpu_get_ticks();
184 timers_state.cpu_clock_offset = cpu_get_clock();
185 timers_state.cpu_ticks_enabled = 0;
186 }
187 }
188
189 /* Correlation between real and virtual time is always going to be
190 fairly approximate, so ignore small variation.
191 When the guest is idle real and virtual time will be aligned in
192 the IO wait loop. */
193 #define ICOUNT_WOBBLE (get_ticks_per_sec() / 10)
194
195 static void icount_adjust(void)
196 {
197 int64_t cur_time;
198 int64_t cur_icount;
199 int64_t delta;
200 static int64_t last_delta;
201 /* If the VM is not running, then do nothing. */
202 if (!runstate_is_running()) {
203 return;
204 }
205 cur_time = cpu_get_clock();
206 cur_icount = qemu_get_clock_ns(vm_clock);
207 delta = cur_icount - cur_time;
208 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
209 if (delta > 0
210 && last_delta + ICOUNT_WOBBLE < delta * 2
211 && icount_time_shift > 0) {
212 /* The guest is getting too far ahead. Slow time down. */
213 icount_time_shift--;
214 }
215 if (delta < 0
216 && last_delta - ICOUNT_WOBBLE > delta * 2
217 && icount_time_shift < MAX_ICOUNT_SHIFT) {
218 /* The guest is getting too far behind. Speed time up. */
219 icount_time_shift++;
220 }
221 last_delta = delta;
222 qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
223 }
224
225 static void icount_adjust_rt(void *opaque)
226 {
227 qemu_mod_timer(icount_rt_timer,
228 qemu_get_clock_ms(rt_clock) + 1000);
229 icount_adjust();
230 }
231
232 static void icount_adjust_vm(void *opaque)
233 {
234 qemu_mod_timer(icount_vm_timer,
235 qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 10);
236 icount_adjust();
237 }
238
239 static int64_t qemu_icount_round(int64_t count)
240 {
241 return (count + (1 << icount_time_shift) - 1) >> icount_time_shift;
242 }
243
244 static void icount_warp_rt(void *opaque)
245 {
246 if (vm_clock_warp_start == -1) {
247 return;
248 }
249
250 if (runstate_is_running()) {
251 int64_t clock = qemu_get_clock_ns(rt_clock);
252 int64_t warp_delta = clock - vm_clock_warp_start;
253 if (use_icount == 1) {
254 qemu_icount_bias += warp_delta;
255 } else {
256 /*
257 * In adaptive mode, do not let the vm_clock run too
258 * far ahead of real time.
259 */
260 int64_t cur_time = cpu_get_clock();
261 int64_t cur_icount = qemu_get_clock_ns(vm_clock);
262 int64_t delta = cur_time - cur_icount;
263 qemu_icount_bias += MIN(warp_delta, delta);
264 }
265 if (qemu_clock_expired(vm_clock)) {
266 qemu_notify_event();
267 }
268 }
269 vm_clock_warp_start = -1;
270 }
271
272 void qtest_clock_warp(int64_t dest)
273 {
274 int64_t clock = qemu_get_clock_ns(vm_clock);
275 assert(qtest_enabled());
276 while (clock < dest) {
277 int64_t deadline = qemu_clock_deadline(vm_clock);
278 int64_t warp = MIN(dest - clock, deadline);
279 qemu_icount_bias += warp;
280 qemu_run_timers(vm_clock);
281 clock = qemu_get_clock_ns(vm_clock);
282 }
283 qemu_notify_event();
284 }
285
286 void qemu_clock_warp(QEMUClock *clock)
287 {
288 int64_t deadline;
289
290 /*
291 * There are too many global variables to make the "warp" behavior
292 * applicable to other clocks. But a clock argument removes the
293 * need for if statements all over the place.
294 */
295 if (clock != vm_clock || !use_icount) {
296 return;
297 }
298
299 /*
300 * If the CPUs have been sleeping, advance the vm_clock timer now. This
301 * ensures that the deadline for the timer is computed correctly below.
302 * This also makes sure that the insn counter is synchronized before the
303 * CPU starts running, in case the CPU is woken by an event other than
304 * the earliest vm_clock timer.
305 */
306 icount_warp_rt(NULL);
307 if (!all_cpu_threads_idle() || !qemu_clock_has_timers(vm_clock)) {
308 qemu_del_timer(icount_warp_timer);
309 return;
310 }
311
312 if (qtest_enabled()) {
313 /* When testing, qtest commands advance icount. */
314 return;
315 }
316
317 vm_clock_warp_start = qemu_get_clock_ns(rt_clock);
318 deadline = qemu_clock_deadline(vm_clock);
319 if (deadline > 0) {
320 /*
321 * Ensure the vm_clock proceeds even when the virtual CPU goes to
322 * sleep. Otherwise, the CPU might be waiting for a future timer
323 * interrupt to wake it up, but the interrupt never comes because
324 * the vCPU isn't running any insns and thus doesn't advance the
325 * vm_clock.
326 *
327 * An extreme solution for this problem would be to never let VCPUs
328 * sleep in icount mode if there is a pending vm_clock timer; rather
329 * time could just advance to the next vm_clock event. Instead, we
330 * do stop VCPUs and only advance vm_clock after some "real" time,
331 * (related to the time left until the next event) has passed. This
332 * rt_clock timer will do this. This avoids that the warps are too
333 * visible externally---for example, you will not be sending network
334 * packets continuously instead of every 100ms.
335 */
336 qemu_mod_timer(icount_warp_timer, vm_clock_warp_start + deadline);
337 } else {
338 qemu_notify_event();
339 }
340 }
341
342 static const VMStateDescription vmstate_timers = {
343 .name = "timer",
344 .version_id = 2,
345 .minimum_version_id = 1,
346 .minimum_version_id_old = 1,
347 .fields = (VMStateField[]) {
348 VMSTATE_INT64(cpu_ticks_offset, TimersState),
349 VMSTATE_INT64(dummy, TimersState),
350 VMSTATE_INT64_V(cpu_clock_offset, TimersState, 2),
351 VMSTATE_END_OF_LIST()
352 }
353 };
354
355 void configure_icount(const char *option)
356 {
357 vmstate_register(NULL, 0, &vmstate_timers, &timers_state);
358 if (!option) {
359 return;
360 }
361
362 icount_warp_timer = qemu_new_timer_ns(rt_clock, icount_warp_rt, NULL);
363 if (strcmp(option, "auto") != 0) {
364 icount_time_shift = strtol(option, NULL, 0);
365 use_icount = 1;
366 return;
367 }
368
369 use_icount = 2;
370
371 /* 125MIPS seems a reasonable initial guess at the guest speed.
372 It will be corrected fairly quickly anyway. */
373 icount_time_shift = 3;
374
375 /* Have both realtime and virtual time triggers for speed adjustment.
376 The realtime trigger catches emulated time passing too slowly,
377 the virtual time trigger catches emulated time passing too fast.
378 Realtime triggers occur even when idle, so use them less frequently
379 than VM triggers. */
380 icount_rt_timer = qemu_new_timer_ms(rt_clock, icount_adjust_rt, NULL);
381 qemu_mod_timer(icount_rt_timer,
382 qemu_get_clock_ms(rt_clock) + 1000);
383 icount_vm_timer = qemu_new_timer_ns(vm_clock, icount_adjust_vm, NULL);
384 qemu_mod_timer(icount_vm_timer,
385 qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 10);
386 }
387
388 /***********************************************************/
389 void hw_error(const char *fmt, ...)
390 {
391 va_list ap;
392 CPUArchState *env;
393 CPUState *cpu;
394
395 va_start(ap, fmt);
396 fprintf(stderr, "qemu: hardware error: ");
397 vfprintf(stderr, fmt, ap);
398 fprintf(stderr, "\n");
399 for (env = first_cpu; env != NULL; env = env->next_cpu) {
400 cpu = ENV_GET_CPU(env);
401 fprintf(stderr, "CPU #%d:\n", cpu->cpu_index);
402 cpu_dump_state(env, stderr, fprintf, CPU_DUMP_FPU);
403 }
404 va_end(ap);
405 abort();
406 }
407
408 void cpu_synchronize_all_states(void)
409 {
410 CPUArchState *cpu;
411
412 for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
413 cpu_synchronize_state(cpu);
414 }
415 }
416
417 void cpu_synchronize_all_post_reset(void)
418 {
419 CPUArchState *cpu;
420
421 for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
422 cpu_synchronize_post_reset(ENV_GET_CPU(cpu));
423 }
424 }
425
426 void cpu_synchronize_all_post_init(void)
427 {
428 CPUArchState *cpu;
429
430 for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
431 cpu_synchronize_post_init(ENV_GET_CPU(cpu));
432 }
433 }
434
435 bool cpu_is_stopped(CPUState *cpu)
436 {
437 return !runstate_is_running() || cpu->stopped;
438 }
439
440 static void do_vm_stop(RunState state)
441 {
442 if (runstate_is_running()) {
443 cpu_disable_ticks();
444 pause_all_vcpus();
445 runstate_set(state);
446 vm_state_notify(0, state);
447 bdrv_drain_all();
448 bdrv_flush_all();
449 monitor_protocol_event(QEVENT_STOP, NULL);
450 }
451 }
452
453 static bool cpu_can_run(CPUState *cpu)
454 {
455 if (cpu->stop) {
456 return false;
457 }
458 if (cpu->stopped || !runstate_is_running()) {
459 return false;
460 }
461 return true;
462 }
463
464 static void cpu_handle_guest_debug(CPUArchState *env)
465 {
466 CPUState *cpu = ENV_GET_CPU(env);
467
468 gdb_set_stop_cpu(env);
469 qemu_system_debug_request();
470 cpu->stopped = true;
471 }
472
473 static void cpu_signal(int sig)
474 {
475 if (cpu_single_env) {
476 cpu_exit(cpu_single_env);
477 }
478 exit_request = 1;
479 }
480
481 #ifdef CONFIG_LINUX
482 static void sigbus_reraise(void)
483 {
484 sigset_t set;
485 struct sigaction action;
486
487 memset(&action, 0, sizeof(action));
488 action.sa_handler = SIG_DFL;
489 if (!sigaction(SIGBUS, &action, NULL)) {
490 raise(SIGBUS);
491 sigemptyset(&set);
492 sigaddset(&set, SIGBUS);
493 sigprocmask(SIG_UNBLOCK, &set, NULL);
494 }
495 perror("Failed to re-raise SIGBUS!\n");
496 abort();
497 }
498
499 static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo,
500 void *ctx)
501 {
502 if (kvm_on_sigbus(siginfo->ssi_code,
503 (void *)(intptr_t)siginfo->ssi_addr)) {
504 sigbus_reraise();
505 }
506 }
507
508 static void qemu_init_sigbus(void)
509 {
510 struct sigaction action;
511
512 memset(&action, 0, sizeof(action));
513 action.sa_flags = SA_SIGINFO;
514 action.sa_sigaction = (void (*)(int, siginfo_t*, void*))sigbus_handler;
515 sigaction(SIGBUS, &action, NULL);
516
517 prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, 0, 0);
518 }
519
520 static void qemu_kvm_eat_signals(CPUState *cpu)
521 {
522 struct timespec ts = { 0, 0 };
523 siginfo_t siginfo;
524 sigset_t waitset;
525 sigset_t chkset;
526 int r;
527
528 sigemptyset(&waitset);
529 sigaddset(&waitset, SIG_IPI);
530 sigaddset(&waitset, SIGBUS);
531
532 do {
533 r = sigtimedwait(&waitset, &siginfo, &ts);
534 if (r == -1 && !(errno == EAGAIN || errno == EINTR)) {
535 perror("sigtimedwait");
536 exit(1);
537 }
538
539 switch (r) {
540 case SIGBUS:
541 if (kvm_on_sigbus_vcpu(cpu, siginfo.si_code, siginfo.si_addr)) {
542 sigbus_reraise();
543 }
544 break;
545 default:
546 break;
547 }
548
549 r = sigpending(&chkset);
550 if (r == -1) {
551 perror("sigpending");
552 exit(1);
553 }
554 } while (sigismember(&chkset, SIG_IPI) || sigismember(&chkset, SIGBUS));
555 }
556
557 #else /* !CONFIG_LINUX */
558
559 static void qemu_init_sigbus(void)
560 {
561 }
562
563 static void qemu_kvm_eat_signals(CPUState *cpu)
564 {
565 }
566 #endif /* !CONFIG_LINUX */
567
568 #ifndef _WIN32
569 static void dummy_signal(int sig)
570 {
571 }
572
573 static void qemu_kvm_init_cpu_signals(CPUArchState *env)
574 {
575 int r;
576 sigset_t set;
577 struct sigaction sigact;
578
579 memset(&sigact, 0, sizeof(sigact));
580 sigact.sa_handler = dummy_signal;
581 sigaction(SIG_IPI, &sigact, NULL);
582
583 pthread_sigmask(SIG_BLOCK, NULL, &set);
584 sigdelset(&set, SIG_IPI);
585 sigdelset(&set, SIGBUS);
586 r = kvm_set_signal_mask(env, &set);
587 if (r) {
588 fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));
589 exit(1);
590 }
591 }
592
593 static void qemu_tcg_init_cpu_signals(void)
594 {
595 sigset_t set;
596 struct sigaction sigact;
597
598 memset(&sigact, 0, sizeof(sigact));
599 sigact.sa_handler = cpu_signal;
600 sigaction(SIG_IPI, &sigact, NULL);
601
602 sigemptyset(&set);
603 sigaddset(&set, SIG_IPI);
604 pthread_sigmask(SIG_UNBLOCK, &set, NULL);
605 }
606
607 #else /* _WIN32 */
608 static void qemu_kvm_init_cpu_signals(CPUArchState *env)
609 {
610 abort();
611 }
612
613 static void qemu_tcg_init_cpu_signals(void)
614 {
615 }
616 #endif /* _WIN32 */
617
618 static QemuMutex qemu_global_mutex;
619 static QemuCond qemu_io_proceeded_cond;
620 static bool iothread_requesting_mutex;
621
622 static QemuThread io_thread;
623
624 static QemuThread *tcg_cpu_thread;
625 static QemuCond *tcg_halt_cond;
626
627 /* cpu creation */
628 static QemuCond qemu_cpu_cond;
629 /* system init */
630 static QemuCond qemu_pause_cond;
631 static QemuCond qemu_work_cond;
632
633 void qemu_init_cpu_loop(void)
634 {
635 qemu_init_sigbus();
636 qemu_cond_init(&qemu_cpu_cond);
637 qemu_cond_init(&qemu_pause_cond);
638 qemu_cond_init(&qemu_work_cond);
639 qemu_cond_init(&qemu_io_proceeded_cond);
640 qemu_mutex_init(&qemu_global_mutex);
641
642 qemu_thread_get_self(&io_thread);
643 }
644
645 void run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data)
646 {
647 struct qemu_work_item wi;
648
649 if (qemu_cpu_is_self(cpu)) {
650 func(data);
651 return;
652 }
653
654 wi.func = func;
655 wi.data = data;
656 if (cpu->queued_work_first == NULL) {
657 cpu->queued_work_first = &wi;
658 } else {
659 cpu->queued_work_last->next = &wi;
660 }
661 cpu->queued_work_last = &wi;
662 wi.next = NULL;
663 wi.done = false;
664
665 qemu_cpu_kick(cpu);
666 while (!wi.done) {
667 CPUArchState *self_env = cpu_single_env;
668
669 qemu_cond_wait(&qemu_work_cond, &qemu_global_mutex);
670 cpu_single_env = self_env;
671 }
672 }
673
674 static void flush_queued_work(CPUState *cpu)
675 {
676 struct qemu_work_item *wi;
677
678 if (cpu->queued_work_first == NULL) {
679 return;
680 }
681
682 while ((wi = cpu->queued_work_first)) {
683 cpu->queued_work_first = wi->next;
684 wi->func(wi->data);
685 wi->done = true;
686 }
687 cpu->queued_work_last = NULL;
688 qemu_cond_broadcast(&qemu_work_cond);
689 }
690
691 static void qemu_wait_io_event_common(CPUState *cpu)
692 {
693 if (cpu->stop) {
694 cpu->stop = false;
695 cpu->stopped = true;
696 qemu_cond_signal(&qemu_pause_cond);
697 }
698 flush_queued_work(cpu);
699 cpu->thread_kicked = false;
700 }
701
702 static void qemu_tcg_wait_io_event(void)
703 {
704 CPUArchState *env;
705
706 while (all_cpu_threads_idle()) {
707 /* Start accounting real time to the virtual clock if the CPUs
708 are idle. */
709 qemu_clock_warp(vm_clock);
710 qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
711 }
712
713 while (iothread_requesting_mutex) {
714 qemu_cond_wait(&qemu_io_proceeded_cond, &qemu_global_mutex);
715 }
716
717 for (env = first_cpu; env != NULL; env = env->next_cpu) {
718 qemu_wait_io_event_common(ENV_GET_CPU(env));
719 }
720 }
721
722 static void qemu_kvm_wait_io_event(CPUArchState *env)
723 {
724 CPUState *cpu = ENV_GET_CPU(env);
725
726 while (cpu_thread_is_idle(env)) {
727 qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
728 }
729
730 qemu_kvm_eat_signals(cpu);
731 qemu_wait_io_event_common(cpu);
732 }
733
734 static void *qemu_kvm_cpu_thread_fn(void *arg)
735 {
736 CPUArchState *env = arg;
737 CPUState *cpu = ENV_GET_CPU(env);
738 int r;
739
740 qemu_mutex_lock(&qemu_global_mutex);
741 qemu_thread_get_self(cpu->thread);
742 cpu->thread_id = qemu_get_thread_id();
743 cpu_single_env = env;
744
745 r = kvm_init_vcpu(cpu);
746 if (r < 0) {
747 fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r));
748 exit(1);
749 }
750
751 qemu_kvm_init_cpu_signals(env);
752
753 /* signal CPU creation */
754 cpu->created = true;
755 qemu_cond_signal(&qemu_cpu_cond);
756
757 while (1) {
758 if (cpu_can_run(cpu)) {
759 r = kvm_cpu_exec(env);
760 if (r == EXCP_DEBUG) {
761 cpu_handle_guest_debug(env);
762 }
763 }
764 qemu_kvm_wait_io_event(env);
765 }
766
767 return NULL;
768 }
769
770 static void *qemu_dummy_cpu_thread_fn(void *arg)
771 {
772 #ifdef _WIN32
773 fprintf(stderr, "qtest is not supported under Windows\n");
774 exit(1);
775 #else
776 CPUArchState *env = arg;
777 CPUState *cpu = ENV_GET_CPU(env);
778 sigset_t waitset;
779 int r;
780
781 qemu_mutex_lock_iothread();
782 qemu_thread_get_self(cpu->thread);
783 cpu->thread_id = qemu_get_thread_id();
784
785 sigemptyset(&waitset);
786 sigaddset(&waitset, SIG_IPI);
787
788 /* signal CPU creation */
789 cpu->created = true;
790 qemu_cond_signal(&qemu_cpu_cond);
791
792 cpu_single_env = env;
793 while (1) {
794 cpu_single_env = NULL;
795 qemu_mutex_unlock_iothread();
796 do {
797 int sig;
798 r = sigwait(&waitset, &sig);
799 } while (r == -1 && (errno == EAGAIN || errno == EINTR));
800 if (r == -1) {
801 perror("sigwait");
802 exit(1);
803 }
804 qemu_mutex_lock_iothread();
805 cpu_single_env = env;
806 qemu_wait_io_event_common(cpu);
807 }
808
809 return NULL;
810 #endif
811 }
812
813 static void tcg_exec_all(void);
814
815 static void tcg_signal_cpu_creation(CPUState *cpu, void *data)
816 {
817 cpu->thread_id = qemu_get_thread_id();
818 cpu->created = true;
819 }
820
821 static void *qemu_tcg_cpu_thread_fn(void *arg)
822 {
823 CPUState *cpu = arg;
824 CPUArchState *env;
825
826 qemu_tcg_init_cpu_signals();
827 qemu_thread_get_self(cpu->thread);
828
829 qemu_mutex_lock(&qemu_global_mutex);
830 qemu_for_each_cpu(tcg_signal_cpu_creation, NULL);
831 qemu_cond_signal(&qemu_cpu_cond);
832
833 /* wait for initial kick-off after machine start */
834 while (ENV_GET_CPU(first_cpu)->stopped) {
835 qemu_cond_wait(tcg_halt_cond, &qemu_global_mutex);
836
837 /* process any pending work */
838 for (env = first_cpu; env != NULL; env = env->next_cpu) {
839 qemu_wait_io_event_common(ENV_GET_CPU(env));
840 }
841 }
842
843 while (1) {
844 tcg_exec_all();
845 if (use_icount && qemu_clock_deadline(vm_clock) <= 0) {
846 qemu_notify_event();
847 }
848 qemu_tcg_wait_io_event();
849 }
850
851 return NULL;
852 }
853
854 static void qemu_cpu_kick_thread(CPUState *cpu)
855 {
856 #ifndef _WIN32
857 int err;
858
859 err = pthread_kill(cpu->thread->thread, SIG_IPI);
860 if (err) {
861 fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
862 exit(1);
863 }
864 #else /* _WIN32 */
865 if (!qemu_cpu_is_self(cpu)) {
866 CONTEXT tcgContext;
867
868 if (SuspendThread(cpu->hThread) == (DWORD)-1) {
869 fprintf(stderr, "qemu:%s: GetLastError:%lu\n", __func__,
870 GetLastError());
871 exit(1);
872 }
873
874 /* On multi-core systems, we are not sure that the thread is actually
875 * suspended until we can get the context.
876 */
877 tcgContext.ContextFlags = CONTEXT_CONTROL;
878 while (GetThreadContext(cpu->hThread, &tcgContext) != 0) {
879 continue;
880 }
881
882 cpu_signal(0);
883
884 if (ResumeThread(cpu->hThread) == (DWORD)-1) {
885 fprintf(stderr, "qemu:%s: GetLastError:%lu\n", __func__,
886 GetLastError());
887 exit(1);
888 }
889 }
890 #endif
891 }
892
893 void qemu_cpu_kick(CPUState *cpu)
894 {
895 qemu_cond_broadcast(cpu->halt_cond);
896 if (!tcg_enabled() && !cpu->thread_kicked) {
897 qemu_cpu_kick_thread(cpu);
898 cpu->thread_kicked = true;
899 }
900 }
901
902 void qemu_cpu_kick_self(void)
903 {
904 #ifndef _WIN32
905 assert(cpu_single_env);
906 CPUState *cpu_single_cpu = ENV_GET_CPU(cpu_single_env);
907
908 if (!cpu_single_cpu->thread_kicked) {
909 qemu_cpu_kick_thread(cpu_single_cpu);
910 cpu_single_cpu->thread_kicked = true;
911 }
912 #else
913 abort();
914 #endif
915 }
916
917 bool qemu_cpu_is_self(CPUState *cpu)
918 {
919 return qemu_thread_is_self(cpu->thread);
920 }
921
922 static bool qemu_in_vcpu_thread(void)
923 {
924 return cpu_single_env && qemu_cpu_is_self(ENV_GET_CPU(cpu_single_env));
925 }
926
927 void qemu_mutex_lock_iothread(void)
928 {
929 if (!tcg_enabled()) {
930 qemu_mutex_lock(&qemu_global_mutex);
931 } else {
932 iothread_requesting_mutex = true;
933 if (qemu_mutex_trylock(&qemu_global_mutex)) {
934 qemu_cpu_kick_thread(ENV_GET_CPU(first_cpu));
935 qemu_mutex_lock(&qemu_global_mutex);
936 }
937 iothread_requesting_mutex = false;
938 qemu_cond_broadcast(&qemu_io_proceeded_cond);
939 }
940 }
941
942 void qemu_mutex_unlock_iothread(void)
943 {
944 qemu_mutex_unlock(&qemu_global_mutex);
945 }
946
947 static int all_vcpus_paused(void)
948 {
949 CPUArchState *penv = first_cpu;
950
951 while (penv) {
952 CPUState *pcpu = ENV_GET_CPU(penv);
953 if (!pcpu->stopped) {
954 return 0;
955 }
956 penv = penv->next_cpu;
957 }
958
959 return 1;
960 }
961
962 void pause_all_vcpus(void)
963 {
964 CPUArchState *penv = first_cpu;
965
966 qemu_clock_enable(vm_clock, false);
967 while (penv) {
968 CPUState *pcpu = ENV_GET_CPU(penv);
969 pcpu->stop = true;
970 qemu_cpu_kick(pcpu);
971 penv = penv->next_cpu;
972 }
973
974 if (qemu_in_vcpu_thread()) {
975 cpu_stop_current();
976 if (!kvm_enabled()) {
977 penv = first_cpu;
978 while (penv) {
979 CPUState *pcpu = ENV_GET_CPU(penv);
980 pcpu->stop = false;
981 pcpu->stopped = true;
982 penv = penv->next_cpu;
983 }
984 return;
985 }
986 }
987
988 while (!all_vcpus_paused()) {
989 qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
990 penv = first_cpu;
991 while (penv) {
992 qemu_cpu_kick(ENV_GET_CPU(penv));
993 penv = penv->next_cpu;
994 }
995 }
996 }
997
998 void cpu_resume(CPUState *cpu)
999 {
1000 cpu->stop = false;
1001 cpu->stopped = false;
1002 qemu_cpu_kick(cpu);
1003 }
1004
1005 void resume_all_vcpus(void)
1006 {
1007 CPUArchState *penv = first_cpu;
1008
1009 qemu_clock_enable(vm_clock, true);
1010 while (penv) {
1011 CPUState *pcpu = ENV_GET_CPU(penv);
1012 cpu_resume(pcpu);
1013 penv = penv->next_cpu;
1014 }
1015 }
1016
1017 static void qemu_tcg_init_vcpu(CPUState *cpu)
1018 {
1019 /* share a single thread for all cpus with TCG */
1020 if (!tcg_cpu_thread) {
1021 cpu->thread = g_malloc0(sizeof(QemuThread));
1022 cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1023 qemu_cond_init(cpu->halt_cond);
1024 tcg_halt_cond = cpu->halt_cond;
1025 qemu_thread_create(cpu->thread, qemu_tcg_cpu_thread_fn, cpu,
1026 QEMU_THREAD_JOINABLE);
1027 #ifdef _WIN32
1028 cpu->hThread = qemu_thread_get_handle(cpu->thread);
1029 #endif
1030 while (!cpu->created) {
1031 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1032 }
1033 tcg_cpu_thread = cpu->thread;
1034 } else {
1035 cpu->thread = tcg_cpu_thread;
1036 cpu->halt_cond = tcg_halt_cond;
1037 }
1038 }
1039
1040 static void qemu_kvm_start_vcpu(CPUArchState *env)
1041 {
1042 CPUState *cpu = ENV_GET_CPU(env);
1043
1044 cpu->thread = g_malloc0(sizeof(QemuThread));
1045 cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1046 qemu_cond_init(cpu->halt_cond);
1047 qemu_thread_create(cpu->thread, qemu_kvm_cpu_thread_fn, env,
1048 QEMU_THREAD_JOINABLE);
1049 while (!cpu->created) {
1050 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1051 }
1052 }
1053
1054 static void qemu_dummy_start_vcpu(CPUArchState *env)
1055 {
1056 CPUState *cpu = ENV_GET_CPU(env);
1057
1058 cpu->thread = g_malloc0(sizeof(QemuThread));
1059 cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1060 qemu_cond_init(cpu->halt_cond);
1061 qemu_thread_create(cpu->thread, qemu_dummy_cpu_thread_fn, env,
1062 QEMU_THREAD_JOINABLE);
1063 while (!cpu->created) {
1064 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1065 }
1066 }
1067
1068 void qemu_init_vcpu(void *_env)
1069 {
1070 CPUArchState *env = _env;
1071 CPUState *cpu = ENV_GET_CPU(env);
1072
1073 cpu->nr_cores = smp_cores;
1074 cpu->nr_threads = smp_threads;
1075 cpu->stopped = true;
1076 if (kvm_enabled()) {
1077 qemu_kvm_start_vcpu(env);
1078 } else if (tcg_enabled()) {
1079 qemu_tcg_init_vcpu(cpu);
1080 } else {
1081 qemu_dummy_start_vcpu(env);
1082 }
1083 }
1084
1085 void cpu_stop_current(void)
1086 {
1087 if (cpu_single_env) {
1088 CPUState *cpu_single_cpu = ENV_GET_CPU(cpu_single_env);
1089 cpu_single_cpu->stop = false;
1090 cpu_single_cpu->stopped = true;
1091 cpu_exit(cpu_single_env);
1092 qemu_cond_signal(&qemu_pause_cond);
1093 }
1094 }
1095
1096 void vm_stop(RunState state)
1097 {
1098 if (qemu_in_vcpu_thread()) {
1099 qemu_system_vmstop_request(state);
1100 /*
1101 * FIXME: should not return to device code in case
1102 * vm_stop() has been requested.
1103 */
1104 cpu_stop_current();
1105 return;
1106 }
1107 do_vm_stop(state);
1108 }
1109
1110 /* does a state transition even if the VM is already stopped,
1111 current state is forgotten forever */
1112 void vm_stop_force_state(RunState state)
1113 {
1114 if (runstate_is_running()) {
1115 vm_stop(state);
1116 } else {
1117 runstate_set(state);
1118 }
1119 }
1120
1121 static int tcg_cpu_exec(CPUArchState *env)
1122 {
1123 int ret;
1124 #ifdef CONFIG_PROFILER
1125 int64_t ti;
1126 #endif
1127
1128 #ifdef CONFIG_PROFILER
1129 ti = profile_getclock();
1130 #endif
1131 if (use_icount) {
1132 int64_t count;
1133 int decr;
1134 qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
1135 env->icount_decr.u16.low = 0;
1136 env->icount_extra = 0;
1137 count = qemu_icount_round(qemu_clock_deadline(vm_clock));
1138 qemu_icount += count;
1139 decr = (count > 0xffff) ? 0xffff : count;
1140 count -= decr;
1141 env->icount_decr.u16.low = decr;
1142 env->icount_extra = count;
1143 }
1144 ret = cpu_exec(env);
1145 #ifdef CONFIG_PROFILER
1146 qemu_time += profile_getclock() - ti;
1147 #endif
1148 if (use_icount) {
1149 /* Fold pending instructions back into the
1150 instruction counter, and clear the interrupt flag. */
1151 qemu_icount -= (env->icount_decr.u16.low
1152 + env->icount_extra);
1153 env->icount_decr.u32 = 0;
1154 env->icount_extra = 0;
1155 }
1156 return ret;
1157 }
1158
1159 static void tcg_exec_all(void)
1160 {
1161 int r;
1162
1163 /* Account partial waits to the vm_clock. */
1164 qemu_clock_warp(vm_clock);
1165
1166 if (next_cpu == NULL) {
1167 next_cpu = first_cpu;
1168 }
1169 for (; next_cpu != NULL && !exit_request; next_cpu = next_cpu->next_cpu) {
1170 CPUArchState *env = next_cpu;
1171 CPUState *cpu = ENV_GET_CPU(env);
1172
1173 qemu_clock_enable(vm_clock,
1174 (env->singlestep_enabled & SSTEP_NOTIMER) == 0);
1175
1176 if (cpu_can_run(cpu)) {
1177 r = tcg_cpu_exec(env);
1178 if (r == EXCP_DEBUG) {
1179 cpu_handle_guest_debug(env);
1180 break;
1181 }
1182 } else if (cpu->stop || cpu->stopped) {
1183 break;
1184 }
1185 }
1186 exit_request = 0;
1187 }
1188
1189 void set_numa_modes(void)
1190 {
1191 CPUArchState *env;
1192 CPUState *cpu;
1193 int i;
1194
1195 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1196 cpu = ENV_GET_CPU(env);
1197 for (i = 0; i < nb_numa_nodes; i++) {
1198 if (test_bit(cpu->cpu_index, node_cpumask[i])) {
1199 cpu->numa_node = i;
1200 }
1201 }
1202 }
1203 }
1204
1205 void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
1206 {
1207 /* XXX: implement xxx_cpu_list for targets that still miss it */
1208 #if defined(cpu_list)
1209 cpu_list(f, cpu_fprintf);
1210 #endif
1211 }
1212
1213 CpuInfoList *qmp_query_cpus(Error **errp)
1214 {
1215 CpuInfoList *head = NULL, *cur_item = NULL;
1216 CPUArchState *env;
1217
1218 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1219 CPUState *cpu = ENV_GET_CPU(env);
1220 CpuInfoList *info;
1221
1222 cpu_synchronize_state(env);
1223
1224 info = g_malloc0(sizeof(*info));
1225 info->value = g_malloc0(sizeof(*info->value));
1226 info->value->CPU = cpu->cpu_index;
1227 info->value->current = (env == first_cpu);
1228 info->value->halted = cpu->halted;
1229 info->value->thread_id = cpu->thread_id;
1230 #if defined(TARGET_I386)
1231 info->value->has_pc = true;
1232 info->value->pc = env->eip + env->segs[R_CS].base;
1233 #elif defined(TARGET_PPC)
1234 info->value->has_nip = true;
1235 info->value->nip = env->nip;
1236 #elif defined(TARGET_SPARC)
1237 info->value->has_pc = true;
1238 info->value->pc = env->pc;
1239 info->value->has_npc = true;
1240 info->value->npc = env->npc;
1241 #elif defined(TARGET_MIPS)
1242 info->value->has_PC = true;
1243 info->value->PC = env->active_tc.PC;
1244 #endif
1245
1246 /* XXX: waiting for the qapi to support GSList */
1247 if (!cur_item) {
1248 head = cur_item = info;
1249 } else {
1250 cur_item->next = info;
1251 cur_item = info;
1252 }
1253 }
1254
1255 return head;
1256 }
1257
1258 void qmp_memsave(int64_t addr, int64_t size, const char *filename,
1259 bool has_cpu, int64_t cpu_index, Error **errp)
1260 {
1261 FILE *f;
1262 uint32_t l;
1263 CPUArchState *env;
1264 CPUState *cpu;
1265 uint8_t buf[1024];
1266
1267 if (!has_cpu) {
1268 cpu_index = 0;
1269 }
1270
1271 cpu = qemu_get_cpu(cpu_index);
1272 if (cpu == NULL) {
1273 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
1274 "a CPU number");
1275 return;
1276 }
1277 env = cpu->env_ptr;
1278
1279 f = fopen(filename, "wb");
1280 if (!f) {
1281 error_set(errp, QERR_OPEN_FILE_FAILED, filename);
1282 return;
1283 }
1284
1285 while (size != 0) {
1286 l = sizeof(buf);
1287 if (l > size)
1288 l = size;
1289 cpu_memory_rw_debug(env, addr, buf, l, 0);
1290 if (fwrite(buf, 1, l, f) != l) {
1291 error_set(errp, QERR_IO_ERROR);
1292 goto exit;
1293 }
1294 addr += l;
1295 size -= l;
1296 }
1297
1298 exit:
1299 fclose(f);
1300 }
1301
1302 void qmp_pmemsave(int64_t addr, int64_t size, const char *filename,
1303 Error **errp)
1304 {
1305 FILE *f;
1306 uint32_t l;
1307 uint8_t buf[1024];
1308
1309 f = fopen(filename, "wb");
1310 if (!f) {
1311 error_set(errp, QERR_OPEN_FILE_FAILED, filename);
1312 return;
1313 }
1314
1315 while (size != 0) {
1316 l = sizeof(buf);
1317 if (l > size)
1318 l = size;
1319 cpu_physical_memory_rw(addr, buf, l, 0);
1320 if (fwrite(buf, 1, l, f) != l) {
1321 error_set(errp, QERR_IO_ERROR);
1322 goto exit;
1323 }
1324 addr += l;
1325 size -= l;
1326 }
1327
1328 exit:
1329 fclose(f);
1330 }
1331
1332 void qmp_inject_nmi(Error **errp)
1333 {
1334 #if defined(TARGET_I386)
1335 CPUArchState *env;
1336
1337 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1338 if (!env->apic_state) {
1339 cpu_interrupt(CPU(x86_env_get_cpu(env)), CPU_INTERRUPT_NMI);
1340 } else {
1341 apic_deliver_nmi(env->apic_state);
1342 }
1343 }
1344 #else
1345 error_set(errp, QERR_UNSUPPORTED);
1346 #endif
1347 }