blob: f298b659f467dd8a0090f88c90db6ea2c882b2fc [file] [log] [blame]
Blue Swirl296af7c2010-03-29 19:23:50 +00001/*
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
Peter Maydell7b31bbc2016-01-26 18:16:56 +000025#include "qemu/osdep.h"
KONRAD Frederic8d4e9142017-02-23 18:29:08 +000026#include "qemu/config-file.h"
Paolo Bonzini33c11872016-03-15 16:58:45 +010027#include "cpu.h"
Paolo Bonzini83c90892012-12-17 18:19:49 +010028#include "monitor/monitor.h"
Markus Armbrustere688df62018-02-01 12:18:31 +010029#include "qapi/error.h"
Wenchao Xiaa4e15de2014-06-18 08:43:36 +020030#include "qapi/qmp/qerror.h"
Markus Armbrusterd49b6832015-03-17 18:29:20 +010031#include "qemu/error-report.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010032#include "sysemu/sysemu.h"
Max Reitzda31d592016-03-16 19:54:32 +010033#include "sysemu/block-backend.h"
Paolo Bonzini022c62c2012-12-17 18:19:49 +010034#include "exec/gdbstub.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010035#include "sysemu/dma.h"
Vincent Palatinb3946622017-01-10 11:59:55 +010036#include "sysemu/hw_accel.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010037#include "sysemu/kvm.h"
Vincent Palatinb0cb0a62017-01-10 11:59:57 +010038#include "sysemu/hax.h"
Sergio Andres Gomez Del Realc97d6d22017-09-13 04:05:09 -050039#include "sysemu/hvf.h"
Justin Terry (VM)19306802018-01-22 13:07:49 -080040#include "sysemu/whpx.h"
Luiz Capitulinode0b36b2011-09-21 16:38:35 -030041#include "qmp-commands.h"
Paolo Bonzini63c91552016-03-15 13:18:37 +010042#include "exec/exec-all.h"
Blue Swirl296af7c2010-03-29 19:23:50 +000043
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010044#include "qemu/thread.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010045#include "sysemu/cpus.h"
46#include "sysemu/qtest.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010047#include "qemu/main-loop.h"
Markus Armbruster922a01a2018-02-01 12:18:46 +010048#include "qemu/option.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010049#include "qemu/bitmap.h"
Liu Ping Fancb365642013-09-25 14:20:58 +080050#include "qemu/seqlock.h"
KONRAD Frederic8d4e9142017-02-23 18:29:08 +000051#include "tcg.h"
Wenchao Xiaa4e15de2014-06-18 08:43:36 +020052#include "qapi-event.h"
Alexey Kardashevskiy9cb805f2014-08-20 22:16:33 +100053#include "hw/nmi.h"
Pavel Dovgalyuk8b427042015-09-17 19:24:05 +030054#include "sysemu/replay.h"
Igor Mammedovafed5a52017-05-10 13:29:55 +020055#include "hw/boards.h"
Jan Kiszka0ff0fc12011-06-23 10:15:55 +020056
Jan Kiszka6d9cb732011-02-01 22:15:58 +010057#ifdef CONFIG_LINUX
58
59#include <sys/prctl.h>
60
Marcelo Tosattic0532a72010-10-11 15:31:21 -030061#ifndef PR_MCE_KILL
62#define PR_MCE_KILL 33
63#endif
64
Jan Kiszka6d9cb732011-02-01 22:15:58 +010065#ifndef PR_MCE_KILL_SET
66#define PR_MCE_KILL_SET 1
67#endif
68
69#ifndef PR_MCE_KILL_EARLY
70#define PR_MCE_KILL_EARLY 1
71#endif
72
73#endif /* CONFIG_LINUX */
74
Sebastian Tanase27498be2014-07-25 11:56:33 +020075int64_t max_delay;
76int64_t max_advance;
Blue Swirl296af7c2010-03-29 19:23:50 +000077
Jason J. Herne2adcc852015-09-08 13:12:33 -040078/* vcpu throttling controls */
79static QEMUTimer *throttle_timer;
80static unsigned int throttle_percentage;
81
82#define CPU_THROTTLE_PCT_MIN 1
83#define CPU_THROTTLE_PCT_MAX 99
84#define CPU_THROTTLE_TIMESLICE_NS 10000000
85
Tiejun Chen321bc0b2013-08-02 09:43:09 +080086bool cpu_is_stopped(CPUState *cpu)
87{
88 return cpu->stopped || !runstate_is_running();
89}
90
Andreas Färbera98ae1d2013-05-26 23:21:08 +020091static bool cpu_thread_is_idle(CPUState *cpu)
Peter Maydellac873f12012-07-19 16:52:27 +010092{
Andreas Färberc64ca812012-05-03 02:11:45 +020093 if (cpu->stop || cpu->queued_work_first) {
Peter Maydellac873f12012-07-19 16:52:27 +010094 return false;
95 }
Tiejun Chen321bc0b2013-08-02 09:43:09 +080096 if (cpu_is_stopped(cpu)) {
Peter Maydellac873f12012-07-19 16:52:27 +010097 return true;
98 }
Andreas Färber8c2e1b02013-08-25 18:53:55 +020099 if (!cpu->halted || cpu_has_work(cpu) ||
Alexander Graf215e79c2013-04-24 22:24:12 +0200100 kvm_halt_in_kernel()) {
Peter Maydellac873f12012-07-19 16:52:27 +0100101 return false;
102 }
103 return true;
104}
105
106static bool all_cpu_threads_idle(void)
107{
Andreas Färber182735e2013-05-29 22:29:20 +0200108 CPUState *cpu;
Peter Maydellac873f12012-07-19 16:52:27 +0100109
Andreas Färberbdc44642013-06-24 23:50:24 +0200110 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +0200111 if (!cpu_thread_is_idle(cpu)) {
Peter Maydellac873f12012-07-19 16:52:27 +0100112 return false;
113 }
114 }
115 return true;
116}
117
Blue Swirl296af7c2010-03-29 19:23:50 +0000118/***********************************************************/
Paolo Bonzini946fb272011-09-12 13:57:37 +0200119/* guest cycle counter */
120
Paolo Bonzinia3270e12013-10-07 17:18:15 +0200121/* Protected by TimersState seqlock */
122
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200123static bool icount_sleep = true;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200124/* Conversion factor from emulated instructions to virtual clock ticks. */
125static int icount_time_shift;
126/* Arbitrarily pick 1MIPS as the minimum allowable speed. */
127#define MAX_ICOUNT_SHIFT 10
Paolo Bonzinia3270e12013-10-07 17:18:15 +0200128
Paolo Bonzini946fb272011-09-12 13:57:37 +0200129typedef struct TimersState {
Liu Ping Fancb365642013-09-25 14:20:58 +0800130 /* Protected by BQL. */
Paolo Bonzini946fb272011-09-12 13:57:37 +0200131 int64_t cpu_ticks_prev;
132 int64_t cpu_ticks_offset;
Liu Ping Fancb365642013-09-25 14:20:58 +0800133
134 /* cpu_clock_offset can be read out of BQL, so protect it with
135 * this lock.
136 */
137 QemuSeqLock vm_clock_seqlock;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200138 int64_t cpu_clock_offset;
139 int32_t cpu_ticks_enabled;
140 int64_t dummy;
KONRAD Fredericc96778b2014-08-01 01:37:09 +0200141
142 /* Compensate for varying guest execution speed. */
143 int64_t qemu_icount_bias;
144 /* Only written by TCG thread */
145 int64_t qemu_icount;
Pavel Dovgalyukb39e3f32018-01-11 11:26:10 +0300146 /* for adjusting icount */
147 int64_t vm_clock_warp_start;
148 QEMUTimer *icount_rt_timer;
149 QEMUTimer *icount_vm_timer;
150 QEMUTimer *icount_warp_timer;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200151} TimersState;
152
Liu Ping Fand9cd4002013-07-21 08:43:00 +0000153static TimersState timers_state;
KONRAD Frederic8d4e9142017-02-23 18:29:08 +0000154bool mttcg_enabled;
155
156/*
157 * We default to false if we know other options have been enabled
158 * which are currently incompatible with MTTCG. Otherwise when each
159 * guest (target) has been updated to support:
160 * - atomic instructions
161 * - memory ordering primitives (barriers)
162 * they can set the appropriate CONFIG flags in ${target}-softmmu.mak
163 *
164 * Once a guest architecture has been converted to the new primitives
165 * there are two remaining limitations to check.
166 *
167 * - The guest can't be oversized (e.g. 64 bit guest on 32 bit host)
168 * - The host must have a stronger memory order than the guest
169 *
170 * It may be possible in future to support strong guests on weak hosts
171 * but that will require tagging all load/stores in a guest with their
172 * implicit memory order requirements which would likely slow things
173 * down a lot.
174 */
175
176static bool check_tcg_memory_orders_compatible(void)
177{
178#if defined(TCG_GUEST_DEFAULT_MO) && defined(TCG_TARGET_DEFAULT_MO)
179 return (TCG_GUEST_DEFAULT_MO & ~TCG_TARGET_DEFAULT_MO) == 0;
180#else
181 return false;
182#endif
183}
184
185static bool default_mttcg_enabled(void)
186{
Alex Bennée83fd9622017-02-27 17:09:01 +0000187 if (use_icount || TCG_OVERSIZED_GUEST) {
KONRAD Frederic8d4e9142017-02-23 18:29:08 +0000188 return false;
189 } else {
190#ifdef TARGET_SUPPORTS_MTTCG
191 return check_tcg_memory_orders_compatible();
192#else
193 return false;
194#endif
195 }
196}
197
198void qemu_tcg_configure(QemuOpts *opts, Error **errp)
199{
200 const char *t = qemu_opt_get(opts, "thread");
201 if (t) {
202 if (strcmp(t, "multi") == 0) {
203 if (TCG_OVERSIZED_GUEST) {
204 error_setg(errp, "No MTTCG when guest word size > hosts");
Alex Bennée83fd9622017-02-27 17:09:01 +0000205 } else if (use_icount) {
206 error_setg(errp, "No MTTCG when icount is enabled");
KONRAD Frederic8d4e9142017-02-23 18:29:08 +0000207 } else {
Nikunj A Dadhania86953502017-04-10 11:36:55 +0530208#ifndef TARGET_SUPPORTS_MTTCG
Alex Bennéec34c7622017-02-28 14:40:17 +0000209 error_report("Guest not yet converted to MTTCG - "
210 "you may get unexpected results");
211#endif
KONRAD Frederic8d4e9142017-02-23 18:29:08 +0000212 if (!check_tcg_memory_orders_compatible()) {
213 error_report("Guest expects a stronger memory ordering "
214 "than the host provides");
Pranith Kumar8cfef892017-03-25 16:19:23 -0400215 error_printf("This may cause strange/hard to debug errors\n");
KONRAD Frederic8d4e9142017-02-23 18:29:08 +0000216 }
217 mttcg_enabled = true;
218 }
219 } else if (strcmp(t, "single") == 0) {
220 mttcg_enabled = false;
221 } else {
222 error_setg(errp, "Invalid 'thread' setting %s", t);
223 }
224 } else {
225 mttcg_enabled = default_mttcg_enabled();
226 }
227}
Paolo Bonzini946fb272011-09-12 13:57:37 +0200228
Alex Bennéee4cd9652017-03-31 16:09:42 +0100229/* The current number of executed instructions is based on what we
230 * originally budgeted minus the current state of the decrementing
231 * icount counters in extra/u16.low.
232 */
233static int64_t cpu_get_icount_executed(CPUState *cpu)
234{
235 return cpu->icount_budget - (cpu->icount_decr.u16.low + cpu->icount_extra);
236}
237
Alex Bennée512d3c82017-04-05 12:32:37 +0100238/*
239 * Update the global shared timer_state.qemu_icount to take into
240 * account executed instructions. This is done by the TCG vCPU
241 * thread so the main-loop can see time has moved forward.
242 */
243void cpu_update_icount(CPUState *cpu)
244{
245 int64_t executed = cpu_get_icount_executed(cpu);
246 cpu->icount_budget -= executed;
247
248#ifdef CONFIG_ATOMIC64
249 atomic_set__nocheck(&timers_state.qemu_icount,
250 atomic_read__nocheck(&timers_state.qemu_icount) +
251 executed);
252#else /* FIXME: we need 64bit atomics to do this safely */
253 timers_state.qemu_icount += executed;
254#endif
255}
256
Pavel Dovgalyuk2a629142014-12-08 10:53:45 +0300257int64_t cpu_get_icount_raw(void)
Paolo Bonzini946fb272011-09-12 13:57:37 +0200258{
Andreas Färber4917cf42013-05-27 05:17:50 +0200259 CPUState *cpu = current_cpu;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200260
Alex Bennée243c5f72017-03-30 18:49:22 +0100261 if (cpu && cpu->running) {
Paolo Bonzini414b15c2015-06-24 14:16:26 +0200262 if (!cpu->can_do_io) {
Alistair Francis493d89b2018-02-03 09:43:14 +0100263 error_report("Bad icount read");
Pavel Dovgalyuk2a629142014-12-08 10:53:45 +0300264 exit(1);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200265 }
Alex Bennéee4cd9652017-03-31 16:09:42 +0100266 /* Take into account what has run */
Alex Bennée1d059062017-04-05 10:53:47 +0100267 cpu_update_icount(cpu);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200268 }
Alex Bennée1d059062017-04-05 10:53:47 +0100269#ifdef CONFIG_ATOMIC64
270 return atomic_read__nocheck(&timers_state.qemu_icount);
271#else /* FIXME: we need 64bit atomics to do this safely */
272 return timers_state.qemu_icount;
273#endif
Pavel Dovgalyuk2a629142014-12-08 10:53:45 +0300274}
275
276/* Return the virtual CPU time, based on the instruction counter. */
277static int64_t cpu_get_icount_locked(void)
278{
279 int64_t icount = cpu_get_icount_raw();
KONRAD Frederic3f031312014-08-01 01:37:15 +0200280 return timers_state.qemu_icount_bias + cpu_icount_to_ns(icount);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200281}
282
Paolo Bonzini17a15f12013-10-03 15:17:25 +0200283int64_t cpu_get_icount(void)
284{
285 int64_t icount;
286 unsigned start;
287
288 do {
289 start = seqlock_read_begin(&timers_state.vm_clock_seqlock);
290 icount = cpu_get_icount_locked();
291 } while (seqlock_read_retry(&timers_state.vm_clock_seqlock, start));
292
293 return icount;
294}
295
KONRAD Frederic3f031312014-08-01 01:37:15 +0200296int64_t cpu_icount_to_ns(int64_t icount)
297{
298 return icount << icount_time_shift;
299}
300
Cao jind90f3cc2016-07-29 19:05:38 +0800301/* return the time elapsed in VM between vm_start and vm_stop. Unless
302 * icount is active, cpu_get_ticks() uses units of the host CPU cycle
303 * counter.
304 *
305 * Caller must hold the BQL
306 */
Paolo Bonzini946fb272011-09-12 13:57:37 +0200307int64_t cpu_get_ticks(void)
308{
Paolo Bonzini5f3e3102013-10-28 17:32:18 +0100309 int64_t ticks;
310
Paolo Bonzini946fb272011-09-12 13:57:37 +0200311 if (use_icount) {
312 return cpu_get_icount();
313 }
Paolo Bonzini5f3e3102013-10-28 17:32:18 +0100314
315 ticks = timers_state.cpu_ticks_offset;
316 if (timers_state.cpu_ticks_enabled) {
Christopher Covington4a7428c2015-09-25 10:42:21 -0400317 ticks += cpu_get_host_ticks();
Paolo Bonzini946fb272011-09-12 13:57:37 +0200318 }
Paolo Bonzini5f3e3102013-10-28 17:32:18 +0100319
320 if (timers_state.cpu_ticks_prev > ticks) {
321 /* Note: non increasing ticks may happen if the host uses
322 software suspend */
323 timers_state.cpu_ticks_offset += timers_state.cpu_ticks_prev - ticks;
324 ticks = timers_state.cpu_ticks_prev;
325 }
326
327 timers_state.cpu_ticks_prev = ticks;
328 return ticks;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200329}
330
Liu Ping Fancb365642013-09-25 14:20:58 +0800331static int64_t cpu_get_clock_locked(void)
332{
Cao jin1d45cea2016-07-29 19:05:37 +0800333 int64_t time;
Liu Ping Fancb365642013-09-25 14:20:58 +0800334
Cao jin1d45cea2016-07-29 19:05:37 +0800335 time = timers_state.cpu_clock_offset;
Paolo Bonzini5f3e3102013-10-28 17:32:18 +0100336 if (timers_state.cpu_ticks_enabled) {
Cao jin1d45cea2016-07-29 19:05:37 +0800337 time += get_clock();
Liu Ping Fancb365642013-09-25 14:20:58 +0800338 }
339
Cao jin1d45cea2016-07-29 19:05:37 +0800340 return time;
Liu Ping Fancb365642013-09-25 14:20:58 +0800341}
342
Cao jind90f3cc2016-07-29 19:05:38 +0800343/* Return the monotonic time elapsed in VM, i.e.,
Peter Maydell8212ff82016-09-15 10:24:22 +0100344 * the time between vm_start and vm_stop
345 */
Paolo Bonzini946fb272011-09-12 13:57:37 +0200346int64_t cpu_get_clock(void)
347{
348 int64_t ti;
Liu Ping Fancb365642013-09-25 14:20:58 +0800349 unsigned start;
350
351 do {
352 start = seqlock_read_begin(&timers_state.vm_clock_seqlock);
353 ti = cpu_get_clock_locked();
354 } while (seqlock_read_retry(&timers_state.vm_clock_seqlock, start));
355
356 return ti;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200357}
358
Liu Ping Fancb365642013-09-25 14:20:58 +0800359/* enable cpu_get_ticks()
Cao jin3224e872016-07-08 18:31:37 +0800360 * Caller must hold BQL which serves as mutex for vm_clock_seqlock.
Liu Ping Fancb365642013-09-25 14:20:58 +0800361 */
Paolo Bonzini946fb272011-09-12 13:57:37 +0200362void cpu_enable_ticks(void)
363{
Liu Ping Fancb365642013-09-25 14:20:58 +0800364 /* Here, the really thing protected by seqlock is cpu_clock_offset. */
Emilio G. Cota03719e42016-06-08 14:55:21 -0400365 seqlock_write_begin(&timers_state.vm_clock_seqlock);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200366 if (!timers_state.cpu_ticks_enabled) {
Christopher Covington4a7428c2015-09-25 10:42:21 -0400367 timers_state.cpu_ticks_offset -= cpu_get_host_ticks();
Paolo Bonzini946fb272011-09-12 13:57:37 +0200368 timers_state.cpu_clock_offset -= get_clock();
369 timers_state.cpu_ticks_enabled = 1;
370 }
Emilio G. Cota03719e42016-06-08 14:55:21 -0400371 seqlock_write_end(&timers_state.vm_clock_seqlock);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200372}
373
374/* disable cpu_get_ticks() : the clock is stopped. You must not call
Liu Ping Fancb365642013-09-25 14:20:58 +0800375 * cpu_get_ticks() after that.
Cao jin3224e872016-07-08 18:31:37 +0800376 * Caller must hold BQL which serves as mutex for vm_clock_seqlock.
Liu Ping Fancb365642013-09-25 14:20:58 +0800377 */
Paolo Bonzini946fb272011-09-12 13:57:37 +0200378void cpu_disable_ticks(void)
379{
Liu Ping Fancb365642013-09-25 14:20:58 +0800380 /* Here, the really thing protected by seqlock is cpu_clock_offset. */
Emilio G. Cota03719e42016-06-08 14:55:21 -0400381 seqlock_write_begin(&timers_state.vm_clock_seqlock);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200382 if (timers_state.cpu_ticks_enabled) {
Christopher Covington4a7428c2015-09-25 10:42:21 -0400383 timers_state.cpu_ticks_offset += cpu_get_host_ticks();
Liu Ping Fancb365642013-09-25 14:20:58 +0800384 timers_state.cpu_clock_offset = cpu_get_clock_locked();
Paolo Bonzini946fb272011-09-12 13:57:37 +0200385 timers_state.cpu_ticks_enabled = 0;
386 }
Emilio G. Cota03719e42016-06-08 14:55:21 -0400387 seqlock_write_end(&timers_state.vm_clock_seqlock);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200388}
389
390/* Correlation between real and virtual time is always going to be
391 fairly approximate, so ignore small variation.
392 When the guest is idle real and virtual time will be aligned in
393 the IO wait loop. */
Rutuja Shah73bcb242016-03-21 21:32:30 +0530394#define ICOUNT_WOBBLE (NANOSECONDS_PER_SECOND / 10)
Paolo Bonzini946fb272011-09-12 13:57:37 +0200395
396static void icount_adjust(void)
397{
398 int64_t cur_time;
399 int64_t cur_icount;
400 int64_t delta;
Paolo Bonzinia3270e12013-10-07 17:18:15 +0200401
402 /* Protected by TimersState mutex. */
Paolo Bonzini946fb272011-09-12 13:57:37 +0200403 static int64_t last_delta;
Paolo Bonzini468cc7c2013-10-07 17:21:51 +0200404
Paolo Bonzini946fb272011-09-12 13:57:37 +0200405 /* If the VM is not running, then do nothing. */
406 if (!runstate_is_running()) {
407 return;
408 }
Paolo Bonzini468cc7c2013-10-07 17:21:51 +0200409
Emilio G. Cota03719e42016-06-08 14:55:21 -0400410 seqlock_write_begin(&timers_state.vm_clock_seqlock);
Paolo Bonzini17a15f12013-10-03 15:17:25 +0200411 cur_time = cpu_get_clock_locked();
412 cur_icount = cpu_get_icount_locked();
Paolo Bonzini468cc7c2013-10-07 17:21:51 +0200413
Paolo Bonzini946fb272011-09-12 13:57:37 +0200414 delta = cur_icount - cur_time;
415 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
416 if (delta > 0
417 && last_delta + ICOUNT_WOBBLE < delta * 2
418 && icount_time_shift > 0) {
419 /* The guest is getting too far ahead. Slow time down. */
420 icount_time_shift--;
421 }
422 if (delta < 0
423 && last_delta - ICOUNT_WOBBLE > delta * 2
424 && icount_time_shift < MAX_ICOUNT_SHIFT) {
425 /* The guest is getting too far behind. Speed time up. */
426 icount_time_shift++;
427 }
428 last_delta = delta;
KONRAD Fredericc96778b2014-08-01 01:37:09 +0200429 timers_state.qemu_icount_bias = cur_icount
430 - (timers_state.qemu_icount << icount_time_shift);
Emilio G. Cota03719e42016-06-08 14:55:21 -0400431 seqlock_write_end(&timers_state.vm_clock_seqlock);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200432}
433
434static void icount_adjust_rt(void *opaque)
435{
Pavel Dovgalyukb39e3f32018-01-11 11:26:10 +0300436 timer_mod(timers_state.icount_rt_timer,
Pavel Dovgalyuk1979b902015-01-12 15:00:43 +0300437 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT) + 1000);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200438 icount_adjust();
439}
440
441static void icount_adjust_vm(void *opaque)
442{
Pavel Dovgalyukb39e3f32018-01-11 11:26:10 +0300443 timer_mod(timers_state.icount_vm_timer,
Alex Bligh40daca52013-08-21 16:03:02 +0100444 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
Rutuja Shah73bcb242016-03-21 21:32:30 +0530445 NANOSECONDS_PER_SECOND / 10);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200446 icount_adjust();
447}
448
449static int64_t qemu_icount_round(int64_t count)
450{
451 return (count + (1 << icount_time_shift) - 1) >> icount_time_shift;
452}
453
Pavel Dovgalyukefab87c2015-09-17 19:24:39 +0300454static void icount_warp_rt(void)
Paolo Bonzini946fb272011-09-12 13:57:37 +0200455{
Alex Bennéeccffff42016-04-04 15:35:48 +0100456 unsigned seq;
457 int64_t warp_start;
458
Paolo Bonzini17a15f12013-10-03 15:17:25 +0200459 /* The icount_warp_timer is rescheduled soon after vm_clock_warp_start
460 * changes from -1 to another value, so the race here is okay.
461 */
Alex Bennéeccffff42016-04-04 15:35:48 +0100462 do {
463 seq = seqlock_read_begin(&timers_state.vm_clock_seqlock);
Pavel Dovgalyukb39e3f32018-01-11 11:26:10 +0300464 warp_start = timers_state.vm_clock_warp_start;
Alex Bennéeccffff42016-04-04 15:35:48 +0100465 } while (seqlock_read_retry(&timers_state.vm_clock_seqlock, seq));
466
467 if (warp_start == -1) {
Paolo Bonzini946fb272011-09-12 13:57:37 +0200468 return;
469 }
470
Emilio G. Cota03719e42016-06-08 14:55:21 -0400471 seqlock_write_begin(&timers_state.vm_clock_seqlock);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200472 if (runstate_is_running()) {
Pavel Dovgalyuk8eda2062015-09-17 19:24:28 +0300473 int64_t clock = REPLAY_CLOCK(REPLAY_CLOCK_VIRTUAL_RT,
474 cpu_get_clock_locked());
Paolo Bonzini8ed961d2013-10-07 17:26:07 +0200475 int64_t warp_delta;
476
Pavel Dovgalyukb39e3f32018-01-11 11:26:10 +0300477 warp_delta = clock - timers_state.vm_clock_warp_start;
Paolo Bonzini8ed961d2013-10-07 17:26:07 +0200478 if (use_icount == 2) {
Paolo Bonzini946fb272011-09-12 13:57:37 +0200479 /*
Alex Bligh40daca52013-08-21 16:03:02 +0100480 * In adaptive mode, do not let QEMU_CLOCK_VIRTUAL run too
Paolo Bonzini946fb272011-09-12 13:57:37 +0200481 * far ahead of real time.
482 */
Paolo Bonzini17a15f12013-10-03 15:17:25 +0200483 int64_t cur_icount = cpu_get_icount_locked();
Pavel Dovgalyukbf2a7dd2014-11-26 13:40:55 +0300484 int64_t delta = clock - cur_icount;
Paolo Bonzini8ed961d2013-10-07 17:26:07 +0200485 warp_delta = MIN(warp_delta, delta);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200486 }
KONRAD Fredericc96778b2014-08-01 01:37:09 +0200487 timers_state.qemu_icount_bias += warp_delta;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200488 }
Pavel Dovgalyukb39e3f32018-01-11 11:26:10 +0300489 timers_state.vm_clock_warp_start = -1;
Emilio G. Cota03719e42016-06-08 14:55:21 -0400490 seqlock_write_end(&timers_state.vm_clock_seqlock);
Paolo Bonzini8ed961d2013-10-07 17:26:07 +0200491
492 if (qemu_clock_expired(QEMU_CLOCK_VIRTUAL)) {
493 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
494 }
Paolo Bonzini946fb272011-09-12 13:57:37 +0200495}
496
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300497static void icount_timer_cb(void *opaque)
Pavel Dovgalyukefab87c2015-09-17 19:24:39 +0300498{
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300499 /* No need for a checkpoint because the timer already synchronizes
500 * with CHECKPOINT_CLOCK_VIRTUAL_RT.
501 */
502 icount_warp_rt();
Pavel Dovgalyukefab87c2015-09-17 19:24:39 +0300503}
504
Paolo Bonzini8156be52012-03-28 15:42:04 +0200505void qtest_clock_warp(int64_t dest)
506{
Alex Bligh40daca52013-08-21 16:03:02 +0100507 int64_t clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
Fam Zhengefef88b2015-01-19 17:51:43 +0800508 AioContext *aio_context;
Paolo Bonzini8156be52012-03-28 15:42:04 +0200509 assert(qtest_enabled());
Fam Zhengefef88b2015-01-19 17:51:43 +0800510 aio_context = qemu_get_aio_context();
Paolo Bonzini8156be52012-03-28 15:42:04 +0200511 while (clock < dest) {
Alex Bligh40daca52013-08-21 16:03:02 +0100512 int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
Sergey Fedorovc9299e22014-06-10 13:10:28 +0400513 int64_t warp = qemu_soonest_timeout(dest - clock, deadline);
Fam Zhengefef88b2015-01-19 17:51:43 +0800514
Emilio G. Cota03719e42016-06-08 14:55:21 -0400515 seqlock_write_begin(&timers_state.vm_clock_seqlock);
KONRAD Fredericc96778b2014-08-01 01:37:09 +0200516 timers_state.qemu_icount_bias += warp;
Emilio G. Cota03719e42016-06-08 14:55:21 -0400517 seqlock_write_end(&timers_state.vm_clock_seqlock);
Paolo Bonzini17a15f12013-10-03 15:17:25 +0200518
Alex Bligh40daca52013-08-21 16:03:02 +0100519 qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
Fam Zhengefef88b2015-01-19 17:51:43 +0800520 timerlist_run_timers(aio_context->tlg.tl[QEMU_CLOCK_VIRTUAL]);
Alex Bligh40daca52013-08-21 16:03:02 +0100521 clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
Paolo Bonzini8156be52012-03-28 15:42:04 +0200522 }
Alex Bligh40daca52013-08-21 16:03:02 +0100523 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
Paolo Bonzini8156be52012-03-28 15:42:04 +0200524}
525
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300526void qemu_start_warp_timer(void)
Paolo Bonzini946fb272011-09-12 13:57:37 +0200527{
Paolo Bonzinice78d182013-10-07 17:30:02 +0200528 int64_t clock;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200529 int64_t deadline;
530
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300531 if (!use_icount) {
Paolo Bonzini946fb272011-09-12 13:57:37 +0200532 return;
533 }
534
Pavel Dovgalyuk8bd7f712015-09-17 19:24:44 +0300535 /* Nothing to do if the VM is stopped: QEMU_CLOCK_VIRTUAL timers
536 * do not fire, so computing the deadline does not make sense.
537 */
538 if (!runstate_is_running()) {
539 return;
540 }
541
542 /* warp clock deterministically in record/replay mode */
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300543 if (!replay_checkpoint(CHECKPOINT_CLOCK_WARP_START)) {
Pavel Dovgalyuk8bd7f712015-09-17 19:24:44 +0300544 return;
545 }
546
Paolo Bonzinice78d182013-10-07 17:30:02 +0200547 if (!all_cpu_threads_idle()) {
Paolo Bonzini946fb272011-09-12 13:57:37 +0200548 return;
549 }
550
Paolo Bonzini8156be52012-03-28 15:42:04 +0200551 if (qtest_enabled()) {
552 /* When testing, qtest commands advance icount. */
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300553 return;
Paolo Bonzini8156be52012-03-28 15:42:04 +0200554 }
555
Alex Blighac70aaf2013-08-21 16:02:57 +0100556 /* We want to use the earliest deadline from ALL vm_clocks */
Pavel Dovgalyukbf2a7dd2014-11-26 13:40:55 +0300557 clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT);
Alex Bligh40daca52013-08-21 16:03:02 +0100558 deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
Paolo Bonzinice78d182013-10-07 17:30:02 +0200559 if (deadline < 0) {
Victor CLEMENTd7a0f712015-05-29 17:14:06 +0200560 static bool notified;
561 if (!icount_sleep && !notified) {
Alistair Francis3dc6f862017-07-12 06:57:41 -0700562 warn_report("icount sleep disabled and no active timers");
Victor CLEMENTd7a0f712015-05-29 17:14:06 +0200563 notified = true;
564 }
Paolo Bonzinice78d182013-10-07 17:30:02 +0200565 return;
Alex Blighac70aaf2013-08-21 16:02:57 +0100566 }
567
Paolo Bonzini946fb272011-09-12 13:57:37 +0200568 if (deadline > 0) {
569 /*
Alex Bligh40daca52013-08-21 16:03:02 +0100570 * Ensure QEMU_CLOCK_VIRTUAL proceeds even when the virtual CPU goes to
Paolo Bonzini946fb272011-09-12 13:57:37 +0200571 * sleep. Otherwise, the CPU might be waiting for a future timer
572 * interrupt to wake it up, but the interrupt never comes because
573 * the vCPU isn't running any insns and thus doesn't advance the
Alex Bligh40daca52013-08-21 16:03:02 +0100574 * QEMU_CLOCK_VIRTUAL.
Paolo Bonzini946fb272011-09-12 13:57:37 +0200575 */
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200576 if (!icount_sleep) {
577 /*
578 * We never let VCPUs sleep in no sleep icount mode.
579 * If there is a pending QEMU_CLOCK_VIRTUAL timer we just advance
580 * to the next QEMU_CLOCK_VIRTUAL event and notify it.
581 * It is useful when we want a deterministic execution time,
582 * isolated from host latencies.
583 */
Emilio G. Cota03719e42016-06-08 14:55:21 -0400584 seqlock_write_begin(&timers_state.vm_clock_seqlock);
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200585 timers_state.qemu_icount_bias += deadline;
Emilio G. Cota03719e42016-06-08 14:55:21 -0400586 seqlock_write_end(&timers_state.vm_clock_seqlock);
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200587 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
588 } else {
589 /*
590 * We do stop VCPUs and only advance QEMU_CLOCK_VIRTUAL after some
591 * "real" time, (related to the time left until the next event) has
592 * passed. The QEMU_CLOCK_VIRTUAL_RT clock will do this.
593 * This avoids that the warps are visible externally; for example,
594 * you will not be sending network packets continuously instead of
595 * every 100ms.
596 */
Emilio G. Cota03719e42016-06-08 14:55:21 -0400597 seqlock_write_begin(&timers_state.vm_clock_seqlock);
Pavel Dovgalyukb39e3f32018-01-11 11:26:10 +0300598 if (timers_state.vm_clock_warp_start == -1
599 || timers_state.vm_clock_warp_start > clock) {
600 timers_state.vm_clock_warp_start = clock;
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200601 }
Emilio G. Cota03719e42016-06-08 14:55:21 -0400602 seqlock_write_end(&timers_state.vm_clock_seqlock);
Pavel Dovgalyukb39e3f32018-01-11 11:26:10 +0300603 timer_mod_anticipate(timers_state.icount_warp_timer,
604 clock + deadline);
Paolo Bonzinice78d182013-10-07 17:30:02 +0200605 }
Alex Blighac70aaf2013-08-21 16:02:57 +0100606 } else if (deadline == 0) {
Alex Bligh40daca52013-08-21 16:03:02 +0100607 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200608 }
609}
610
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300611static void qemu_account_warp_timer(void)
612{
613 if (!use_icount || !icount_sleep) {
614 return;
615 }
616
617 /* Nothing to do if the VM is stopped: QEMU_CLOCK_VIRTUAL timers
618 * do not fire, so computing the deadline does not make sense.
619 */
620 if (!runstate_is_running()) {
621 return;
622 }
623
624 /* warp clock deterministically in record/replay mode */
625 if (!replay_checkpoint(CHECKPOINT_CLOCK_WARP_ACCOUNT)) {
626 return;
627 }
628
Pavel Dovgalyukb39e3f32018-01-11 11:26:10 +0300629 timer_del(timers_state.icount_warp_timer);
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300630 icount_warp_rt();
631}
632
KONRAD Fredericd09eae32014-08-01 01:37:10 +0200633static bool icount_state_needed(void *opaque)
634{
635 return use_icount;
636}
637
Pavel Dovgalyukb39e3f32018-01-11 11:26:10 +0300638static bool warp_timer_state_needed(void *opaque)
639{
640 TimersState *s = opaque;
641 return s->icount_warp_timer != NULL;
642}
643
644static bool adjust_timers_state_needed(void *opaque)
645{
646 TimersState *s = opaque;
647 return s->icount_rt_timer != NULL;
648}
649
650/*
651 * Subsection for warp timer migration is optional, because may not be created
652 */
653static const VMStateDescription icount_vmstate_warp_timer = {
654 .name = "timer/icount/warp_timer",
655 .version_id = 1,
656 .minimum_version_id = 1,
657 .needed = warp_timer_state_needed,
658 .fields = (VMStateField[]) {
659 VMSTATE_INT64(vm_clock_warp_start, TimersState),
660 VMSTATE_TIMER_PTR(icount_warp_timer, TimersState),
661 VMSTATE_END_OF_LIST()
662 }
663};
664
665static const VMStateDescription icount_vmstate_adjust_timers = {
666 .name = "timer/icount/timers",
667 .version_id = 1,
668 .minimum_version_id = 1,
669 .needed = adjust_timers_state_needed,
670 .fields = (VMStateField[]) {
671 VMSTATE_TIMER_PTR(icount_rt_timer, TimersState),
672 VMSTATE_TIMER_PTR(icount_vm_timer, TimersState),
673 VMSTATE_END_OF_LIST()
674 }
675};
676
KONRAD Fredericd09eae32014-08-01 01:37:10 +0200677/*
678 * This is a subsection for icount migration.
679 */
680static const VMStateDescription icount_vmstate_timers = {
681 .name = "timer/icount",
682 .version_id = 1,
683 .minimum_version_id = 1,
Juan Quintela5cd8cad2014-09-23 14:09:54 +0200684 .needed = icount_state_needed,
KONRAD Fredericd09eae32014-08-01 01:37:10 +0200685 .fields = (VMStateField[]) {
686 VMSTATE_INT64(qemu_icount_bias, TimersState),
687 VMSTATE_INT64(qemu_icount, TimersState),
688 VMSTATE_END_OF_LIST()
Pavel Dovgalyukb39e3f32018-01-11 11:26:10 +0300689 },
690 .subsections = (const VMStateDescription*[]) {
691 &icount_vmstate_warp_timer,
692 &icount_vmstate_adjust_timers,
693 NULL
KONRAD Fredericd09eae32014-08-01 01:37:10 +0200694 }
695};
696
Paolo Bonzini946fb272011-09-12 13:57:37 +0200697static const VMStateDescription vmstate_timers = {
698 .name = "timer",
699 .version_id = 2,
700 .minimum_version_id = 1,
Juan Quintela35d08452014-04-16 16:01:33 +0200701 .fields = (VMStateField[]) {
Paolo Bonzini946fb272011-09-12 13:57:37 +0200702 VMSTATE_INT64(cpu_ticks_offset, TimersState),
703 VMSTATE_INT64(dummy, TimersState),
704 VMSTATE_INT64_V(cpu_clock_offset, TimersState, 2),
705 VMSTATE_END_OF_LIST()
KONRAD Fredericd09eae32014-08-01 01:37:10 +0200706 },
Juan Quintela5cd8cad2014-09-23 14:09:54 +0200707 .subsections = (const VMStateDescription*[]) {
708 &icount_vmstate_timers,
709 NULL
Paolo Bonzini946fb272011-09-12 13:57:37 +0200710 }
711};
712
Paolo Bonzini14e6fe12016-10-31 10:36:08 +0100713static void cpu_throttle_thread(CPUState *cpu, run_on_cpu_data opaque)
Jason J. Herne2adcc852015-09-08 13:12:33 -0400714{
Jason J. Herne2adcc852015-09-08 13:12:33 -0400715 double pct;
716 double throttle_ratio;
717 long sleeptime_ns;
718
719 if (!cpu_throttle_get_percentage()) {
720 return;
721 }
722
723 pct = (double)cpu_throttle_get_percentage()/100;
724 throttle_ratio = pct / (1 - pct);
725 sleeptime_ns = (long)(throttle_ratio * CPU_THROTTLE_TIMESLICE_NS);
726
727 qemu_mutex_unlock_iothread();
Jason J. Herne2adcc852015-09-08 13:12:33 -0400728 g_usleep(sleeptime_ns / 1000); /* Convert ns to us for usleep call */
729 qemu_mutex_lock_iothread();
Felipe Franciosi90bb0c02017-05-19 22:29:50 +0100730 atomic_set(&cpu->throttle_thread_scheduled, 0);
Jason J. Herne2adcc852015-09-08 13:12:33 -0400731}
732
733static void cpu_throttle_timer_tick(void *opaque)
734{
735 CPUState *cpu;
736 double pct;
737
738 /* Stop the timer if needed */
739 if (!cpu_throttle_get_percentage()) {
740 return;
741 }
742 CPU_FOREACH(cpu) {
743 if (!atomic_xchg(&cpu->throttle_thread_scheduled, 1)) {
Paolo Bonzini14e6fe12016-10-31 10:36:08 +0100744 async_run_on_cpu(cpu, cpu_throttle_thread,
745 RUN_ON_CPU_NULL);
Jason J. Herne2adcc852015-09-08 13:12:33 -0400746 }
747 }
748
749 pct = (double)cpu_throttle_get_percentage()/100;
750 timer_mod(throttle_timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT) +
751 CPU_THROTTLE_TIMESLICE_NS / (1-pct));
752}
753
754void cpu_throttle_set(int new_throttle_pct)
755{
756 /* Ensure throttle percentage is within valid range */
757 new_throttle_pct = MIN(new_throttle_pct, CPU_THROTTLE_PCT_MAX);
758 new_throttle_pct = MAX(new_throttle_pct, CPU_THROTTLE_PCT_MIN);
759
760 atomic_set(&throttle_percentage, new_throttle_pct);
761
762 timer_mod(throttle_timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT) +
763 CPU_THROTTLE_TIMESLICE_NS);
764}
765
766void cpu_throttle_stop(void)
767{
768 atomic_set(&throttle_percentage, 0);
769}
770
771bool cpu_throttle_active(void)
772{
773 return (cpu_throttle_get_percentage() != 0);
774}
775
776int cpu_throttle_get_percentage(void)
777{
778 return atomic_read(&throttle_percentage);
779}
780
Pavel Dovgalyuk4603ea02014-09-01 09:34:49 +0400781void cpu_ticks_init(void)
782{
Emilio G. Cotaccdb3c12016-06-08 14:55:20 -0400783 seqlock_init(&timers_state.vm_clock_seqlock);
Pavel Dovgalyuk4603ea02014-09-01 09:34:49 +0400784 vmstate_register(NULL, 0, &vmstate_timers, &timers_state);
Jason J. Herne2adcc852015-09-08 13:12:33 -0400785 throttle_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL_RT,
786 cpu_throttle_timer_tick, NULL);
Pavel Dovgalyuk4603ea02014-09-01 09:34:49 +0400787}
788
Sebastian Tanase1ad95802014-07-25 11:56:28 +0200789void configure_icount(QemuOpts *opts, Error **errp)
Paolo Bonzini946fb272011-09-12 13:57:37 +0200790{
Sebastian Tanase1ad95802014-07-25 11:56:28 +0200791 const char *option;
Sebastian Tanasea8bfac32014-07-25 11:56:29 +0200792 char *rem_str = NULL;
Sebastian Tanase1ad95802014-07-25 11:56:28 +0200793
Sebastian Tanase1ad95802014-07-25 11:56:28 +0200794 option = qemu_opt_get(opts, "shift");
Paolo Bonzini946fb272011-09-12 13:57:37 +0200795 if (!option) {
Sebastian Tanasea8bfac32014-07-25 11:56:29 +0200796 if (qemu_opt_get(opts, "align") != NULL) {
797 error_setg(errp, "Please specify shift option when using align");
798 }
Paolo Bonzini946fb272011-09-12 13:57:37 +0200799 return;
800 }
Victor CLEMENTf1f4b572015-05-29 17:14:05 +0200801
802 icount_sleep = qemu_opt_get_bool(opts, "sleep", true);
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200803 if (icount_sleep) {
Pavel Dovgalyukb39e3f32018-01-11 11:26:10 +0300804 timers_state.icount_warp_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL_RT,
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300805 icount_timer_cb, NULL);
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200806 }
Victor CLEMENTf1f4b572015-05-29 17:14:05 +0200807
Sebastian Tanasea8bfac32014-07-25 11:56:29 +0200808 icount_align_option = qemu_opt_get_bool(opts, "align", false);
Victor CLEMENTf1f4b572015-05-29 17:14:05 +0200809
810 if (icount_align_option && !icount_sleep) {
Pranith Kumar778d9f92016-02-26 10:16:51 -0500811 error_setg(errp, "align=on and sleep=off are incompatible");
Victor CLEMENTf1f4b572015-05-29 17:14:05 +0200812 }
Paolo Bonzini946fb272011-09-12 13:57:37 +0200813 if (strcmp(option, "auto") != 0) {
Sebastian Tanasea8bfac32014-07-25 11:56:29 +0200814 errno = 0;
815 icount_time_shift = strtol(option, &rem_str, 0);
816 if (errno != 0 || *rem_str != '\0' || !strlen(option)) {
817 error_setg(errp, "icount: Invalid shift value");
818 }
Paolo Bonzini946fb272011-09-12 13:57:37 +0200819 use_icount = 1;
820 return;
Sebastian Tanasea8bfac32014-07-25 11:56:29 +0200821 } else if (icount_align_option) {
822 error_setg(errp, "shift=auto and align=on are incompatible");
Victor CLEMENTf1f4b572015-05-29 17:14:05 +0200823 } else if (!icount_sleep) {
Pranith Kumar778d9f92016-02-26 10:16:51 -0500824 error_setg(errp, "shift=auto and sleep=off are incompatible");
Paolo Bonzini946fb272011-09-12 13:57:37 +0200825 }
826
827 use_icount = 2;
828
829 /* 125MIPS seems a reasonable initial guess at the guest speed.
830 It will be corrected fairly quickly anyway. */
831 icount_time_shift = 3;
832
833 /* Have both realtime and virtual time triggers for speed adjustment.
834 The realtime trigger catches emulated time passing too slowly,
835 the virtual time trigger catches emulated time passing too fast.
836 Realtime triggers occur even when idle, so use them less frequently
837 than VM triggers. */
Pavel Dovgalyukb39e3f32018-01-11 11:26:10 +0300838 timers_state.vm_clock_warp_start = -1;
839 timers_state.icount_rt_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL_RT,
Pavel Dovgalyukbf2a7dd2014-11-26 13:40:55 +0300840 icount_adjust_rt, NULL);
Pavel Dovgalyukb39e3f32018-01-11 11:26:10 +0300841 timer_mod(timers_state.icount_rt_timer,
Pavel Dovgalyukbf2a7dd2014-11-26 13:40:55 +0300842 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT) + 1000);
Pavel Dovgalyukb39e3f32018-01-11 11:26:10 +0300843 timers_state.icount_vm_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
Alex Bligh40daca52013-08-21 16:03:02 +0100844 icount_adjust_vm, NULL);
Pavel Dovgalyukb39e3f32018-01-11 11:26:10 +0300845 timer_mod(timers_state.icount_vm_timer,
Alex Bligh40daca52013-08-21 16:03:02 +0100846 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
Rutuja Shah73bcb242016-03-21 21:32:30 +0530847 NANOSECONDS_PER_SECOND / 10);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200848}
849
850/***********************************************************/
Alex Bennée65467062017-02-23 18:29:09 +0000851/* TCG vCPU kick timer
852 *
853 * The kick timer is responsible for moving single threaded vCPU
854 * emulation on to the next vCPU. If more than one vCPU is running a
855 * timer event with force a cpu->exit so the next vCPU can get
856 * scheduled.
857 *
858 * The timer is removed if all vCPUs are idle and restarted again once
859 * idleness is complete.
860 */
861
862static QEMUTimer *tcg_kick_vcpu_timer;
Alex Bennée791158d2017-02-23 18:29:10 +0000863static CPUState *tcg_current_rr_cpu;
Alex Bennée65467062017-02-23 18:29:09 +0000864
865#define TCG_KICK_PERIOD (NANOSECONDS_PER_SECOND / 10)
866
867static inline int64_t qemu_tcg_next_kick(void)
868{
869 return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + TCG_KICK_PERIOD;
870}
871
Alex Bennée791158d2017-02-23 18:29:10 +0000872/* Kick the currently round-robin scheduled vCPU */
873static void qemu_cpu_kick_rr_cpu(void)
874{
875 CPUState *cpu;
Alex Bennée791158d2017-02-23 18:29:10 +0000876 do {
877 cpu = atomic_mb_read(&tcg_current_rr_cpu);
878 if (cpu) {
879 cpu_exit(cpu);
880 }
881 } while (cpu != atomic_mb_read(&tcg_current_rr_cpu));
882}
883
Paolo Bonzini6b8f0182017-03-02 19:56:40 +0100884static void do_nothing(CPUState *cpu, run_on_cpu_data unused)
885{
886}
887
Paolo Bonzini3f53bc62017-03-03 11:50:29 +0100888void qemu_timer_notify_cb(void *opaque, QEMUClockType type)
889{
Paolo Bonzini6b8f0182017-03-02 19:56:40 +0100890 if (!use_icount || type != QEMU_CLOCK_VIRTUAL) {
891 qemu_notify_event();
892 return;
893 }
894
895 if (!qemu_in_vcpu_thread() && first_cpu) {
896 /* qemu_cpu_kick is not enough to kick a halted CPU out of
897 * qemu_tcg_wait_io_event. async_run_on_cpu, instead,
898 * causes cpu_thread_is_idle to return false. This way,
899 * handle_icount_deadline can run.
900 */
901 async_run_on_cpu(first_cpu, do_nothing, RUN_ON_CPU_NULL);
902 }
Paolo Bonzini3f53bc62017-03-03 11:50:29 +0100903}
904
Alex Bennée65467062017-02-23 18:29:09 +0000905static void kick_tcg_thread(void *opaque)
906{
907 timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
Alex Bennée791158d2017-02-23 18:29:10 +0000908 qemu_cpu_kick_rr_cpu();
Alex Bennée65467062017-02-23 18:29:09 +0000909}
910
911static void start_tcg_kick_timer(void)
912{
Paolo Bonzinidb08b682018-01-11 13:53:12 +0100913 assert(!mttcg_enabled);
914 if (!tcg_kick_vcpu_timer && CPU_NEXT(first_cpu)) {
Alex Bennée65467062017-02-23 18:29:09 +0000915 tcg_kick_vcpu_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
916 kick_tcg_thread, NULL);
917 timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
918 }
919}
920
921static void stop_tcg_kick_timer(void)
922{
Paolo Bonzinidb08b682018-01-11 13:53:12 +0100923 assert(!mttcg_enabled);
Alex Bennée65467062017-02-23 18:29:09 +0000924 if (tcg_kick_vcpu_timer) {
925 timer_del(tcg_kick_vcpu_timer);
926 tcg_kick_vcpu_timer = NULL;
927 }
928}
929
Alex Bennée65467062017-02-23 18:29:09 +0000930/***********************************************************/
Blue Swirl296af7c2010-03-29 19:23:50 +0000931void hw_error(const char *fmt, ...)
932{
933 va_list ap;
Andreas Färber55e5c282012-12-17 06:18:02 +0100934 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +0000935
936 va_start(ap, fmt);
937 fprintf(stderr, "qemu: hardware error: ");
938 vfprintf(stderr, fmt, ap);
939 fprintf(stderr, "\n");
Andreas Färberbdc44642013-06-24 23:50:24 +0200940 CPU_FOREACH(cpu) {
Andreas Färber55e5c282012-12-17 06:18:02 +0100941 fprintf(stderr, "CPU #%d:\n", cpu->cpu_index);
Andreas Färber878096e2013-05-27 01:33:50 +0200942 cpu_dump_state(cpu, stderr, fprintf, CPU_DUMP_FPU);
Blue Swirl296af7c2010-03-29 19:23:50 +0000943 }
944 va_end(ap);
945 abort();
946}
947
948void cpu_synchronize_all_states(void)
949{
Andreas Färber182735e2013-05-29 22:29:20 +0200950 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +0000951
Andreas Färberbdc44642013-06-24 23:50:24 +0200952 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +0200953 cpu_synchronize_state(cpu);
Sergio Andres Gomez Del Realc97d6d22017-09-13 04:05:09 -0500954 /* TODO: move to cpu_synchronize_state() */
955 if (hvf_enabled()) {
956 hvf_cpu_synchronize_state(cpu);
957 }
Blue Swirl296af7c2010-03-29 19:23:50 +0000958 }
959}
960
961void cpu_synchronize_all_post_reset(void)
962{
Andreas Färber182735e2013-05-29 22:29:20 +0200963 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +0000964
Andreas Färberbdc44642013-06-24 23:50:24 +0200965 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +0200966 cpu_synchronize_post_reset(cpu);
Sergio Andres Gomez Del Realc97d6d22017-09-13 04:05:09 -0500967 /* TODO: move to cpu_synchronize_post_reset() */
968 if (hvf_enabled()) {
969 hvf_cpu_synchronize_post_reset(cpu);
970 }
Blue Swirl296af7c2010-03-29 19:23:50 +0000971 }
972}
973
974void cpu_synchronize_all_post_init(void)
975{
Andreas Färber182735e2013-05-29 22:29:20 +0200976 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +0000977
Andreas Färberbdc44642013-06-24 23:50:24 +0200978 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +0200979 cpu_synchronize_post_init(cpu);
Sergio Andres Gomez Del Realc97d6d22017-09-13 04:05:09 -0500980 /* TODO: move to cpu_synchronize_post_init() */
981 if (hvf_enabled()) {
982 hvf_cpu_synchronize_post_init(cpu);
983 }
Blue Swirl296af7c2010-03-29 19:23:50 +0000984 }
985}
986
David Gibson75e972d2017-05-26 14:46:28 +1000987void cpu_synchronize_all_pre_loadvm(void)
988{
989 CPUState *cpu;
990
991 CPU_FOREACH(cpu) {
992 cpu_synchronize_pre_loadvm(cpu);
993 }
994}
995
Kevin Wolf56983462013-07-05 13:49:54 +0200996static int do_vm_stop(RunState state)
Blue Swirl296af7c2010-03-29 19:23:50 +0000997{
Kevin Wolf56983462013-07-05 13:49:54 +0200998 int ret = 0;
999
Luiz Capitulino13548692011-07-29 15:36:43 -03001000 if (runstate_is_running()) {
Blue Swirl296af7c2010-03-29 19:23:50 +00001001 cpu_disable_ticks();
Blue Swirl296af7c2010-03-29 19:23:50 +00001002 pause_all_vcpus();
Luiz Capitulinof5bbfba2011-07-29 15:04:45 -03001003 runstate_set(state);
Luiz Capitulino1dfb4dd2011-07-29 14:26:33 -03001004 vm_state_notify(0, state);
Wenchao Xiaa4e15de2014-06-18 08:43:36 +02001005 qapi_event_send_stop(&error_abort);
Blue Swirl296af7c2010-03-29 19:23:50 +00001006 }
Kevin Wolf56983462013-07-05 13:49:54 +02001007
Kevin Wolf594a45c2013-07-18 14:52:19 +02001008 bdrv_drain_all();
Pavel Dovgalyuk6d0ceb82016-09-26 11:08:16 +03001009 replay_disable_events();
John Snow22af08e2016-09-22 21:45:51 -04001010 ret = bdrv_flush_all();
Kevin Wolf594a45c2013-07-18 14:52:19 +02001011
Kevin Wolf56983462013-07-05 13:49:54 +02001012 return ret;
Blue Swirl296af7c2010-03-29 19:23:50 +00001013}
1014
Andreas Färbera1fcaa72012-05-02 23:42:26 +02001015static bool cpu_can_run(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +00001016{
Andreas Färber4fdeee72012-05-02 23:10:09 +02001017 if (cpu->stop) {
Andreas Färbera1fcaa72012-05-02 23:42:26 +02001018 return false;
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001019 }
Tiejun Chen321bc0b2013-08-02 09:43:09 +08001020 if (cpu_is_stopped(cpu)) {
Andreas Färbera1fcaa72012-05-02 23:42:26 +02001021 return false;
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001022 }
Andreas Färbera1fcaa72012-05-02 23:42:26 +02001023 return true;
Blue Swirl296af7c2010-03-29 19:23:50 +00001024}
1025
Andreas Färber91325042013-05-27 02:07:49 +02001026static void cpu_handle_guest_debug(CPUState *cpu)
Jan Kiszka3c638d02010-06-25 16:56:56 +02001027{
Andreas Färber64f6b342013-05-27 02:06:09 +02001028 gdb_set_stop_cpu(cpu);
Jan Kiszka8cf71712011-02-07 12:19:16 +01001029 qemu_system_debug_request();
Andreas Färberf324e762012-05-02 23:26:21 +02001030 cpu->stopped = true;
Jan Kiszka3c638d02010-06-25 16:56:56 +02001031}
1032
Jan Kiszka6d9cb732011-02-01 22:15:58 +01001033#ifdef CONFIG_LINUX
1034static void sigbus_reraise(void)
1035{
1036 sigset_t set;
1037 struct sigaction action;
1038
1039 memset(&action, 0, sizeof(action));
1040 action.sa_handler = SIG_DFL;
1041 if (!sigaction(SIGBUS, &action, NULL)) {
1042 raise(SIGBUS);
1043 sigemptyset(&set);
1044 sigaddset(&set, SIGBUS);
Peter Maydella2d17612016-05-16 18:33:59 +01001045 pthread_sigmask(SIG_UNBLOCK, &set, NULL);
Jan Kiszka6d9cb732011-02-01 22:15:58 +01001046 }
1047 perror("Failed to re-raise SIGBUS!\n");
1048 abort();
1049}
1050
Paolo Bonzinid98d4072017-02-08 13:22:12 +01001051static void sigbus_handler(int n, siginfo_t *siginfo, void *ctx)
Jan Kiszka6d9cb732011-02-01 22:15:58 +01001052{
Paolo Bonzinia16fc072017-02-09 09:50:02 +01001053 if (siginfo->si_code != BUS_MCEERR_AO && siginfo->si_code != BUS_MCEERR_AR) {
1054 sigbus_reraise();
1055 }
1056
Paolo Bonzini2ae41db2017-02-08 12:48:54 +01001057 if (current_cpu) {
1058 /* Called asynchronously in VCPU thread. */
1059 if (kvm_on_sigbus_vcpu(current_cpu, siginfo->si_code, siginfo->si_addr)) {
1060 sigbus_reraise();
1061 }
1062 } else {
1063 /* Called synchronously (via signalfd) in main thread. */
1064 if (kvm_on_sigbus(siginfo->si_code, siginfo->si_addr)) {
1065 sigbus_reraise();
1066 }
Jan Kiszka6d9cb732011-02-01 22:15:58 +01001067 }
1068}
1069
1070static void qemu_init_sigbus(void)
1071{
1072 struct sigaction action;
1073
1074 memset(&action, 0, sizeof(action));
1075 action.sa_flags = SA_SIGINFO;
Paolo Bonzinid98d4072017-02-08 13:22:12 +01001076 action.sa_sigaction = sigbus_handler;
Jan Kiszka6d9cb732011-02-01 22:15:58 +01001077 sigaction(SIGBUS, &action, NULL);
1078
1079 prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, 0, 0);
1080}
Paolo Bonzinia16fc072017-02-09 09:50:02 +01001081#else /* !CONFIG_LINUX */
1082static void qemu_init_sigbus(void)
1083{
1084}
Paolo Bonzinia16fc072017-02-09 09:50:02 +01001085#endif /* !CONFIG_LINUX */
Blue Swirl296af7c2010-03-29 19:23:50 +00001086
Stefan Weilb2532d82012-09-27 07:41:42 +02001087static QemuMutex qemu_global_mutex;
Blue Swirl296af7c2010-03-29 19:23:50 +00001088
1089static QemuThread io_thread;
1090
Blue Swirl296af7c2010-03-29 19:23:50 +00001091/* cpu creation */
1092static QemuCond qemu_cpu_cond;
1093/* system init */
Blue Swirl296af7c2010-03-29 19:23:50 +00001094static QemuCond qemu_pause_cond;
1095
Paolo Bonzinid3b12f52011-09-13 10:30:52 +02001096void qemu_init_cpu_loop(void)
Blue Swirl296af7c2010-03-29 19:23:50 +00001097{
Jan Kiszka6d9cb732011-02-01 22:15:58 +01001098 qemu_init_sigbus();
Anthony Liguoried945922011-02-08 18:18:18 +01001099 qemu_cond_init(&qemu_cpu_cond);
Anthony Liguoried945922011-02-08 18:18:18 +01001100 qemu_cond_init(&qemu_pause_cond);
Blue Swirl296af7c2010-03-29 19:23:50 +00001101 qemu_mutex_init(&qemu_global_mutex);
Blue Swirl296af7c2010-03-29 19:23:50 +00001102
Jan Kiszkab7680cb2011-03-12 17:43:51 +01001103 qemu_thread_get_self(&io_thread);
Blue Swirl296af7c2010-03-29 19:23:50 +00001104}
1105
Paolo Bonzini14e6fe12016-10-31 10:36:08 +01001106void run_on_cpu(CPUState *cpu, run_on_cpu_func func, run_on_cpu_data data)
Marcelo Tosattie82bcec2010-05-04 09:45:22 -03001107{
Sergey Fedorovd148d902016-08-29 09:51:00 +02001108 do_run_on_cpu(cpu, func, data, &qemu_global_mutex);
Chegu Vinod3c022702013-06-24 03:49:41 -06001109}
1110
Gu Zheng4c055ab2016-05-12 09:18:13 +05301111static void qemu_kvm_destroy_vcpu(CPUState *cpu)
1112{
1113 if (kvm_destroy_vcpu(cpu) < 0) {
1114 error_report("kvm_destroy_vcpu failed");
1115 exit(EXIT_FAILURE);
1116 }
1117}
1118
1119static void qemu_tcg_destroy_vcpu(CPUState *cpu)
1120{
1121}
1122
David Hildenbrandebd05fe2017-11-29 20:12:15 +01001123static void qemu_cpu_stop(CPUState *cpu, bool exit)
1124{
1125 g_assert(qemu_cpu_is_self(cpu));
1126 cpu->stop = false;
1127 cpu->stopped = true;
1128 if (exit) {
1129 cpu_exit(cpu);
1130 }
1131 qemu_cond_broadcast(&qemu_pause_cond);
1132}
1133
Andreas Färber509a0d72012-05-03 02:18:09 +02001134static void qemu_wait_io_event_common(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +00001135{
Alex Bennée37257942017-02-23 18:29:14 +00001136 atomic_mb_set(&cpu->thread_kicked, false);
Andreas Färber4fdeee72012-05-02 23:10:09 +02001137 if (cpu->stop) {
David Hildenbrandebd05fe2017-11-29 20:12:15 +01001138 qemu_cpu_stop(cpu, false);
Blue Swirl296af7c2010-03-29 19:23:50 +00001139 }
Sergey Fedorova5403c62016-08-02 18:27:36 +01001140 process_queued_cpu_work(cpu);
Alex Bennée37257942017-02-23 18:29:14 +00001141}
1142
Paolo Bonzinidb08b682018-01-11 13:53:12 +01001143static void qemu_tcg_rr_wait_io_event(CPUState *cpu)
Alex Bennée37257942017-02-23 18:29:14 +00001144{
Paolo Bonzinidb08b682018-01-11 13:53:12 +01001145 while (all_cpu_threads_idle()) {
Alex Bennée65467062017-02-23 18:29:09 +00001146 stop_tcg_kick_timer();
KONRAD Fredericd5f8d612015-08-10 17:27:06 +02001147 qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
Jan Kiszka16400322011-02-09 16:29:37 +01001148 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001149
Alex Bennée65467062017-02-23 18:29:09 +00001150 start_tcg_kick_timer();
1151
Alex Bennée37257942017-02-23 18:29:14 +00001152 qemu_wait_io_event_common(cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +00001153}
1154
Paolo Bonzinidb08b682018-01-11 13:53:12 +01001155static void qemu_wait_io_event(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +00001156{
Andreas Färbera98ae1d2013-05-26 23:21:08 +02001157 while (cpu_thread_is_idle(cpu)) {
Andreas Färberf5c121b2012-05-03 01:22:49 +02001158 qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
Jan Kiszka16400322011-02-09 16:29:37 +01001159 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001160
Paolo Bonzinidb08b682018-01-11 13:53:12 +01001161#ifdef _WIN32
1162 /* Eat dummy APC queued by qemu_cpu_kick_thread. */
1163 if (!tcg_enabled()) {
1164 SleepEx(0, TRUE);
Sergio Andres Gomez Del Realc97d6d22017-09-13 04:05:09 -05001165 }
Paolo Bonzinidb08b682018-01-11 13:53:12 +01001166#endif
Sergio Andres Gomez Del Realc97d6d22017-09-13 04:05:09 -05001167 qemu_wait_io_event_common(cpu);
1168}
1169
Jan Kiszka7e97cd82011-02-07 12:19:12 +01001170static void *qemu_kvm_cpu_thread_fn(void *arg)
Blue Swirl296af7c2010-03-29 19:23:50 +00001171{
Andreas Färber48a106b2013-05-27 02:20:39 +02001172 CPUState *cpu = arg;
Jan Kiszka84b49152011-02-01 22:15:50 +01001173 int r;
Blue Swirl296af7c2010-03-29 19:23:50 +00001174
Paolo Bonziniab28bd22015-07-09 08:55:38 +02001175 rcu_register_thread();
1176
Paolo Bonzini2e7f7a32015-06-18 18:47:18 +02001177 qemu_mutex_lock_iothread();
Andreas Färber814e6122012-05-02 17:00:37 +02001178 qemu_thread_get_self(cpu->thread);
Andreas Färber9f09e182012-05-03 06:59:07 +02001179 cpu->thread_id = qemu_get_thread_id();
Pavel Dovgalyuk626cf8f2014-12-08 10:53:17 +03001180 cpu->can_do_io = 1;
Andreas Färber4917cf42013-05-27 05:17:50 +02001181 current_cpu = cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +00001182
Andreas Färber504134d2012-12-17 06:38:45 +01001183 r = kvm_init_vcpu(cpu);
Jan Kiszka84b49152011-02-01 22:15:50 +01001184 if (r < 0) {
Alistair Francis493d89b2018-02-03 09:43:14 +01001185 error_report("kvm_init_vcpu failed: %s", strerror(-r));
Jan Kiszka84b49152011-02-01 22:15:50 +01001186 exit(1);
1187 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001188
Paolo Bonzini18268b62017-02-09 09:41:14 +01001189 kvm_init_cpu_signals(cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +00001190
1191 /* signal CPU creation */
Andreas Färber61a46212012-05-02 22:49:36 +02001192 cpu->created = true;
Blue Swirl296af7c2010-03-29 19:23:50 +00001193 qemu_cond_signal(&qemu_cpu_cond);
1194
Gu Zheng4c055ab2016-05-12 09:18:13 +05301195 do {
Andreas Färbera1fcaa72012-05-02 23:42:26 +02001196 if (cpu_can_run(cpu)) {
Andreas Färber1458c362013-05-26 23:46:55 +02001197 r = kvm_cpu_exec(cpu);
Jan Kiszka83f338f2011-02-07 12:19:17 +01001198 if (r == EXCP_DEBUG) {
Andreas Färber91325042013-05-27 02:07:49 +02001199 cpu_handle_guest_debug(cpu);
Jan Kiszka83f338f2011-02-07 12:19:17 +01001200 }
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001201 }
Paolo Bonzinidb08b682018-01-11 13:53:12 +01001202 qemu_wait_io_event(cpu);
Gu Zheng4c055ab2016-05-12 09:18:13 +05301203 } while (!cpu->unplug || cpu_can_run(cpu));
Blue Swirl296af7c2010-03-29 19:23:50 +00001204
Gu Zheng4c055ab2016-05-12 09:18:13 +05301205 qemu_kvm_destroy_vcpu(cpu);
Bharata B Rao2c579042016-05-12 09:18:14 +05301206 cpu->created = false;
1207 qemu_cond_signal(&qemu_cpu_cond);
Gu Zheng4c055ab2016-05-12 09:18:13 +05301208 qemu_mutex_unlock_iothread();
Paolo Bonzini57615ed2018-01-30 11:04:36 -05001209 rcu_unregister_thread();
Blue Swirl296af7c2010-03-29 19:23:50 +00001210 return NULL;
1211}
1212
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001213static void *qemu_dummy_cpu_thread_fn(void *arg)
1214{
1215#ifdef _WIN32
Alistair Francis493d89b2018-02-03 09:43:14 +01001216 error_report("qtest is not supported under Windows");
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001217 exit(1);
1218#else
Andreas Färber10a90212013-05-27 02:24:35 +02001219 CPUState *cpu = arg;
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001220 sigset_t waitset;
1221 int r;
1222
Paolo Bonziniab28bd22015-07-09 08:55:38 +02001223 rcu_register_thread();
1224
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001225 qemu_mutex_lock_iothread();
Andreas Färber814e6122012-05-02 17:00:37 +02001226 qemu_thread_get_self(cpu->thread);
Andreas Färber9f09e182012-05-03 06:59:07 +02001227 cpu->thread_id = qemu_get_thread_id();
Pavel Dovgalyuk626cf8f2014-12-08 10:53:17 +03001228 cpu->can_do_io = 1;
Alex Bennée37257942017-02-23 18:29:14 +00001229 current_cpu = cpu;
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001230
1231 sigemptyset(&waitset);
1232 sigaddset(&waitset, SIG_IPI);
1233
1234 /* signal CPU creation */
Andreas Färber61a46212012-05-02 22:49:36 +02001235 cpu->created = true;
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001236 qemu_cond_signal(&qemu_cpu_cond);
1237
Paolo Bonzinid2831ab2018-01-30 11:04:53 -05001238 do {
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001239 qemu_mutex_unlock_iothread();
1240 do {
1241 int sig;
1242 r = sigwait(&waitset, &sig);
1243 } while (r == -1 && (errno == EAGAIN || errno == EINTR));
1244 if (r == -1) {
1245 perror("sigwait");
1246 exit(1);
1247 }
1248 qemu_mutex_lock_iothread();
Paolo Bonzinidb08b682018-01-11 13:53:12 +01001249 qemu_wait_io_event(cpu);
Paolo Bonzinid2831ab2018-01-30 11:04:53 -05001250 } while (!cpu->unplug);
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001251
Paolo Bonzinid2831ab2018-01-30 11:04:53 -05001252 rcu_unregister_thread();
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001253 return NULL;
1254#endif
1255}
1256
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001257static int64_t tcg_get_icount_limit(void)
1258{
1259 int64_t deadline;
1260
1261 if (replay_mode != REPLAY_MODE_PLAY) {
1262 deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
1263
1264 /* Maintain prior (possibly buggy) behaviour where if no deadline
1265 * was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than
1266 * INT32_MAX nanoseconds ahead, we still use INT32_MAX
1267 * nanoseconds.
1268 */
1269 if ((deadline < 0) || (deadline > INT32_MAX)) {
1270 deadline = INT32_MAX;
1271 }
1272
1273 return qemu_icount_round(deadline);
1274 } else {
1275 return replay_get_instructions();
1276 }
1277}
1278
Alex Bennée12e97002016-10-27 16:10:14 +01001279static void handle_icount_deadline(void)
1280{
Paolo Bonzini6b8f0182017-03-02 19:56:40 +01001281 assert(qemu_in_vcpu_thread());
Alex Bennée12e97002016-10-27 16:10:14 +01001282 if (use_icount) {
1283 int64_t deadline =
1284 qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
1285
1286 if (deadline == 0) {
Paolo Bonzini6b8f0182017-03-02 19:56:40 +01001287 /* Wake up other AioContexts. */
Alex Bennée12e97002016-10-27 16:10:14 +01001288 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
Paolo Bonzini6b8f0182017-03-02 19:56:40 +01001289 qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
Alex Bennée12e97002016-10-27 16:10:14 +01001290 }
1291 }
1292}
1293
Alex Bennée05248382017-03-29 16:46:59 +01001294static void prepare_icount_for_run(CPUState *cpu)
1295{
1296 if (use_icount) {
Alex Bennéeeda5f7c2017-04-05 12:35:48 +01001297 int insns_left;
Alex Bennée05248382017-03-29 16:46:59 +01001298
1299 /* These should always be cleared by process_icount_data after
1300 * each vCPU execution. However u16.high can be raised
1301 * asynchronously by cpu_exit/cpu_interrupt/tcg_handle_interrupt
1302 */
1303 g_assert(cpu->icount_decr.u16.low == 0);
1304 g_assert(cpu->icount_extra == 0);
1305
Alex Bennéeeda5f7c2017-04-05 12:35:48 +01001306 cpu->icount_budget = tcg_get_icount_limit();
1307 insns_left = MIN(0xffff, cpu->icount_budget);
1308 cpu->icount_decr.u16.low = insns_left;
1309 cpu->icount_extra = cpu->icount_budget - insns_left;
Alex Bennée05248382017-03-29 16:46:59 +01001310 }
1311}
1312
1313static void process_icount_data(CPUState *cpu)
1314{
1315 if (use_icount) {
Alex Bennéee4cd9652017-03-31 16:09:42 +01001316 /* Account for executed instructions */
Alex Bennée512d3c82017-04-05 12:32:37 +01001317 cpu_update_icount(cpu);
Alex Bennée05248382017-03-29 16:46:59 +01001318
1319 /* Reset the counters */
1320 cpu->icount_decr.u16.low = 0;
1321 cpu->icount_extra = 0;
Alex Bennéee4cd9652017-03-31 16:09:42 +01001322 cpu->icount_budget = 0;
1323
Alex Bennée05248382017-03-29 16:46:59 +01001324 replay_account_executed_instructions();
1325 }
1326}
1327
1328
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001329static int tcg_cpu_exec(CPUState *cpu)
1330{
1331 int ret;
1332#ifdef CONFIG_PROFILER
1333 int64_t ti;
1334#endif
1335
1336#ifdef CONFIG_PROFILER
1337 ti = profile_getclock();
1338#endif
Jan Kiszka8d04fb52017-02-23 18:29:11 +00001339 qemu_mutex_unlock_iothread();
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001340 cpu_exec_start(cpu);
1341 ret = cpu_exec(cpu);
1342 cpu_exec_end(cpu);
Jan Kiszka8d04fb52017-02-23 18:29:11 +00001343 qemu_mutex_lock_iothread();
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001344#ifdef CONFIG_PROFILER
1345 tcg_time += profile_getclock() - ti;
1346#endif
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001347 return ret;
1348}
1349
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001350/* Destroy any remaining vCPUs which have been unplugged and have
1351 * finished running
1352 */
1353static void deal_with_unplugged_cpus(void)
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001354{
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001355 CPUState *cpu;
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001356
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001357 CPU_FOREACH(cpu) {
1358 if (cpu->unplug && !cpu_can_run(cpu)) {
1359 qemu_tcg_destroy_vcpu(cpu);
1360 cpu->created = false;
1361 qemu_cond_signal(&qemu_cpu_cond);
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001362 break;
1363 }
1364 }
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001365}
Jan Kiszkabdb7ca62011-09-26 09:40:39 +02001366
Alex Bennée65467062017-02-23 18:29:09 +00001367/* Single-threaded TCG
1368 *
1369 * In the single-threaded case each vCPU is simulated in turn. If
1370 * there is more than a single vCPU we create a simple timer to kick
1371 * the vCPU and ensure we don't get stuck in a tight loop in one vCPU.
1372 * This is done explicitly rather than relying on side-effects
1373 * elsewhere.
1374 */
1375
Alex Bennée37257942017-02-23 18:29:14 +00001376static void *qemu_tcg_rr_cpu_thread_fn(void *arg)
Blue Swirl296af7c2010-03-29 19:23:50 +00001377{
Andreas Färberc3586ba2012-05-03 01:41:24 +02001378 CPUState *cpu = arg;
Blue Swirl296af7c2010-03-29 19:23:50 +00001379
Paolo Bonziniab28bd22015-07-09 08:55:38 +02001380 rcu_register_thread();
Emilio G. Cota3468b592017-07-19 18:57:58 -04001381 tcg_register_thread();
Paolo Bonziniab28bd22015-07-09 08:55:38 +02001382
Paolo Bonzini2e7f7a32015-06-18 18:47:18 +02001383 qemu_mutex_lock_iothread();
Andreas Färber814e6122012-05-02 17:00:37 +02001384 qemu_thread_get_self(cpu->thread);
Blue Swirl296af7c2010-03-29 19:23:50 +00001385
Andreas Färber38fcbd32013-07-07 19:50:23 +02001386 CPU_FOREACH(cpu) {
1387 cpu->thread_id = qemu_get_thread_id();
1388 cpu->created = true;
Pavel Dovgalyuk626cf8f2014-12-08 10:53:17 +03001389 cpu->can_do_io = 1;
Andreas Färber38fcbd32013-07-07 19:50:23 +02001390 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001391 qemu_cond_signal(&qemu_cpu_cond);
1392
Jan Kiszkafa7d1862011-08-22 18:35:25 +02001393 /* wait for initial kick-off after machine start */
Emilio G. Cotac28e3992015-04-27 12:45:28 -04001394 while (first_cpu->stopped) {
KONRAD Fredericd5f8d612015-08-10 17:27:06 +02001395 qemu_cond_wait(first_cpu->halt_cond, &qemu_global_mutex);
Jan Kiszka8e564b42012-02-17 18:31:15 +01001396
1397 /* process any pending work */
Andreas Färberbdc44642013-06-24 23:50:24 +02001398 CPU_FOREACH(cpu) {
Alex Bennée37257942017-02-23 18:29:14 +00001399 current_cpu = cpu;
Andreas Färber182735e2013-05-29 22:29:20 +02001400 qemu_wait_io_event_common(cpu);
Jan Kiszka8e564b42012-02-17 18:31:15 +01001401 }
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001402 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001403
Alex Bennée65467062017-02-23 18:29:09 +00001404 start_tcg_kick_timer();
1405
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001406 cpu = first_cpu;
1407
Alex Bennéee5143e32017-02-23 18:29:12 +00001408 /* process any pending work */
1409 cpu->exit_request = 1;
1410
Blue Swirl296af7c2010-03-29 19:23:50 +00001411 while (1) {
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001412 /* Account partial waits to QEMU_CLOCK_VIRTUAL. */
1413 qemu_account_warp_timer();
1414
Paolo Bonzini6b8f0182017-03-02 19:56:40 +01001415 /* Run the timers here. This is much more efficient than
1416 * waking up the I/O thread and waiting for completion.
1417 */
1418 handle_icount_deadline();
1419
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001420 if (!cpu) {
1421 cpu = first_cpu;
1422 }
1423
Alex Bennéee5143e32017-02-23 18:29:12 +00001424 while (cpu && !cpu->queued_work_first && !cpu->exit_request) {
1425
Alex Bennée791158d2017-02-23 18:29:10 +00001426 atomic_mb_set(&tcg_current_rr_cpu, cpu);
Alex Bennée37257942017-02-23 18:29:14 +00001427 current_cpu = cpu;
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001428
1429 qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
1430 (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);
1431
1432 if (cpu_can_run(cpu)) {
1433 int r;
Alex Bennée05248382017-03-29 16:46:59 +01001434
1435 prepare_icount_for_run(cpu);
1436
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001437 r = tcg_cpu_exec(cpu);
Alex Bennée05248382017-03-29 16:46:59 +01001438
1439 process_icount_data(cpu);
1440
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001441 if (r == EXCP_DEBUG) {
1442 cpu_handle_guest_debug(cpu);
1443 break;
Pranith Kumar08e73c42017-02-23 18:29:15 +00001444 } else if (r == EXCP_ATOMIC) {
1445 qemu_mutex_unlock_iothread();
1446 cpu_exec_step_atomic(cpu);
1447 qemu_mutex_lock_iothread();
1448 break;
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001449 }
Alex Bennée37257942017-02-23 18:29:14 +00001450 } else if (cpu->stop) {
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001451 if (cpu->unplug) {
1452 cpu = CPU_NEXT(cpu);
1453 }
1454 break;
1455 }
1456
Alex Bennéee5143e32017-02-23 18:29:12 +00001457 cpu = CPU_NEXT(cpu);
1458 } /* while (cpu && !cpu->exit_request).. */
1459
Alex Bennée791158d2017-02-23 18:29:10 +00001460 /* Does not need atomic_mb_set because a spurious wakeup is okay. */
1461 atomic_set(&tcg_current_rr_cpu, NULL);
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001462
Alex Bennéee5143e32017-02-23 18:29:12 +00001463 if (cpu && cpu->exit_request) {
1464 atomic_mb_set(&cpu->exit_request, 0);
1465 }
Alex Blighac70aaf2013-08-21 16:02:57 +01001466
Paolo Bonzinidb08b682018-01-11 13:53:12 +01001467 qemu_tcg_rr_wait_io_event(cpu ? cpu : QTAILQ_FIRST(&cpus));
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001468 deal_with_unplugged_cpus();
Blue Swirl296af7c2010-03-29 19:23:50 +00001469 }
1470
Paolo Bonzini9b0605f2018-01-30 11:05:06 -05001471 rcu_unregister_thread();
Blue Swirl296af7c2010-03-29 19:23:50 +00001472 return NULL;
1473}
1474
Vincent Palatinb0cb0a62017-01-10 11:59:57 +01001475static void *qemu_hax_cpu_thread_fn(void *arg)
1476{
1477 CPUState *cpu = arg;
1478 int r;
Vincent Palatinb3d3a422017-03-20 11:15:49 +01001479
Paolo Bonzini9857c2d2018-01-30 16:28:49 +01001480 rcu_register_thread();
Vincent Palatinb3d3a422017-03-20 11:15:49 +01001481 qemu_mutex_lock_iothread();
Vincent Palatinb0cb0a62017-01-10 11:59:57 +01001482 qemu_thread_get_self(cpu->thread);
Vincent Palatinb0cb0a62017-01-10 11:59:57 +01001483
1484 cpu->thread_id = qemu_get_thread_id();
1485 cpu->created = true;
1486 cpu->halted = 0;
1487 current_cpu = cpu;
1488
1489 hax_init_vcpu(cpu);
1490 qemu_cond_signal(&qemu_cpu_cond);
1491
Paolo Bonzini9857c2d2018-01-30 16:28:49 +01001492 do {
Vincent Palatinb0cb0a62017-01-10 11:59:57 +01001493 if (cpu_can_run(cpu)) {
1494 r = hax_smp_cpu_exec(cpu);
1495 if (r == EXCP_DEBUG) {
1496 cpu_handle_guest_debug(cpu);
1497 }
1498 }
1499
Paolo Bonzinidb08b682018-01-11 13:53:12 +01001500 qemu_wait_io_event(cpu);
Paolo Bonzini9857c2d2018-01-30 16:28:49 +01001501 } while (!cpu->unplug || cpu_can_run(cpu));
1502 rcu_unregister_thread();
Vincent Palatinb0cb0a62017-01-10 11:59:57 +01001503 return NULL;
1504}
1505
Sergio Andres Gomez Del Realc97d6d22017-09-13 04:05:09 -05001506/* The HVF-specific vCPU thread function. This one should only run when the host
1507 * CPU supports the VMX "unrestricted guest" feature. */
1508static void *qemu_hvf_cpu_thread_fn(void *arg)
1509{
1510 CPUState *cpu = arg;
1511
1512 int r;
1513
1514 assert(hvf_enabled());
1515
1516 rcu_register_thread();
1517
1518 qemu_mutex_lock_iothread();
1519 qemu_thread_get_self(cpu->thread);
1520
1521 cpu->thread_id = qemu_get_thread_id();
1522 cpu->can_do_io = 1;
1523 current_cpu = cpu;
1524
1525 hvf_init_vcpu(cpu);
1526
1527 /* signal CPU creation */
1528 cpu->created = true;
1529 qemu_cond_signal(&qemu_cpu_cond);
1530
1531 do {
1532 if (cpu_can_run(cpu)) {
1533 r = hvf_vcpu_exec(cpu);
1534 if (r == EXCP_DEBUG) {
1535 cpu_handle_guest_debug(cpu);
1536 }
1537 }
Paolo Bonzinidb08b682018-01-11 13:53:12 +01001538 qemu_wait_io_event(cpu);
Sergio Andres Gomez Del Realc97d6d22017-09-13 04:05:09 -05001539 } while (!cpu->unplug || cpu_can_run(cpu));
1540
1541 hvf_vcpu_destroy(cpu);
1542 cpu->created = false;
1543 qemu_cond_signal(&qemu_cpu_cond);
1544 qemu_mutex_unlock_iothread();
Paolo Bonzini8178e632018-01-30 11:05:21 -05001545 rcu_unregister_thread();
Sergio Andres Gomez Del Realc97d6d22017-09-13 04:05:09 -05001546 return NULL;
1547}
1548
Justin Terry (VM)19306802018-01-22 13:07:49 -08001549static void *qemu_whpx_cpu_thread_fn(void *arg)
1550{
1551 CPUState *cpu = arg;
1552 int r;
1553
1554 rcu_register_thread();
1555
1556 qemu_mutex_lock_iothread();
1557 qemu_thread_get_self(cpu->thread);
1558 cpu->thread_id = qemu_get_thread_id();
1559 current_cpu = cpu;
1560
1561 r = whpx_init_vcpu(cpu);
1562 if (r < 0) {
1563 fprintf(stderr, "whpx_init_vcpu failed: %s\n", strerror(-r));
1564 exit(1);
1565 }
1566
1567 /* signal CPU creation */
1568 cpu->created = true;
1569 qemu_cond_signal(&qemu_cpu_cond);
1570
1571 do {
1572 if (cpu_can_run(cpu)) {
1573 r = whpx_vcpu_exec(cpu);
1574 if (r == EXCP_DEBUG) {
1575 cpu_handle_guest_debug(cpu);
1576 }
1577 }
1578 while (cpu_thread_is_idle(cpu)) {
1579 qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
1580 }
1581 qemu_wait_io_event_common(cpu);
1582 } while (!cpu->unplug || cpu_can_run(cpu));
1583
1584 whpx_destroy_vcpu(cpu);
1585 cpu->created = false;
1586 qemu_cond_signal(&qemu_cpu_cond);
1587 qemu_mutex_unlock_iothread();
1588 rcu_unregister_thread();
Vincent Palatinb0cb0a62017-01-10 11:59:57 +01001589 return NULL;
1590}
1591
1592#ifdef _WIN32
1593static void CALLBACK dummy_apc_func(ULONG_PTR unused)
1594{
1595}
1596#endif
1597
Alex Bennée37257942017-02-23 18:29:14 +00001598/* Multi-threaded TCG
1599 *
1600 * In the multi-threaded case each vCPU has its own thread. The TLS
1601 * variable current_cpu can be used deep in the code to find the
1602 * current CPUState for a given thread.
1603 */
1604
1605static void *qemu_tcg_cpu_thread_fn(void *arg)
1606{
1607 CPUState *cpu = arg;
1608
Alex Bennéebf51c722017-03-30 18:32:29 +01001609 g_assert(!use_icount);
1610
Alex Bennée37257942017-02-23 18:29:14 +00001611 rcu_register_thread();
Emilio G. Cota3468b592017-07-19 18:57:58 -04001612 tcg_register_thread();
Alex Bennée37257942017-02-23 18:29:14 +00001613
1614 qemu_mutex_lock_iothread();
1615 qemu_thread_get_self(cpu->thread);
1616
1617 cpu->thread_id = qemu_get_thread_id();
1618 cpu->created = true;
1619 cpu->can_do_io = 1;
1620 current_cpu = cpu;
1621 qemu_cond_signal(&qemu_cpu_cond);
1622
1623 /* process any pending work */
1624 cpu->exit_request = 1;
1625
1626 while (1) {
1627 if (cpu_can_run(cpu)) {
1628 int r;
1629 r = tcg_cpu_exec(cpu);
1630 switch (r) {
1631 case EXCP_DEBUG:
1632 cpu_handle_guest_debug(cpu);
1633 break;
1634 case EXCP_HALTED:
1635 /* during start-up the vCPU is reset and the thread is
1636 * kicked several times. If we don't ensure we go back
1637 * to sleep in the halted state we won't cleanly
1638 * start-up when the vCPU is enabled.
1639 *
1640 * cpu->halted should ensure we sleep in wait_io_event
1641 */
1642 g_assert(cpu->halted);
1643 break;
Pranith Kumar08e73c42017-02-23 18:29:15 +00001644 case EXCP_ATOMIC:
1645 qemu_mutex_unlock_iothread();
1646 cpu_exec_step_atomic(cpu);
1647 qemu_mutex_lock_iothread();
Alex Bennée37257942017-02-23 18:29:14 +00001648 default:
1649 /* Ignore everything else? */
1650 break;
1651 }
1652 }
1653
Alex Bennée37257942017-02-23 18:29:14 +00001654 atomic_mb_set(&cpu->exit_request, 0);
Paolo Bonzinidb08b682018-01-11 13:53:12 +01001655 qemu_wait_io_event(cpu);
Paolo Bonzini9b0605f2018-01-30 11:05:06 -05001656 } while (!cpu->unplug || cpu_can_run(cpu));
Alex Bennée37257942017-02-23 18:29:14 +00001657
Paolo Bonzini9b0605f2018-01-30 11:05:06 -05001658 qemu_tcg_destroy_vcpu(cpu);
1659 cpu->created = false;
1660 qemu_cond_signal(&qemu_cpu_cond);
1661 qemu_mutex_unlock_iothread();
1662 rcu_unregister_thread();
Alex Bennée37257942017-02-23 18:29:14 +00001663 return NULL;
1664}
1665
Andreas Färber2ff09a42012-05-03 00:23:30 +02001666static void qemu_cpu_kick_thread(CPUState *cpu)
Paolo Bonzinicc015e92011-03-12 17:44:08 +01001667{
1668#ifndef _WIN32
1669 int err;
1670
Paolo Bonzinie0c38212015-08-26 00:19:19 +02001671 if (cpu->thread_kicked) {
1672 return;
Paolo Bonzini9102ded2015-08-18 06:52:09 -07001673 }
Paolo Bonzinie0c38212015-08-26 00:19:19 +02001674 cpu->thread_kicked = true;
Andreas Färber814e6122012-05-02 17:00:37 +02001675 err = pthread_kill(cpu->thread->thread, SIG_IPI);
Paolo Bonzinicc015e92011-03-12 17:44:08 +01001676 if (err) {
1677 fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
1678 exit(1);
1679 }
1680#else /* _WIN32 */
Vincent Palatinb0cb0a62017-01-10 11:59:57 +01001681 if (!qemu_cpu_is_self(cpu)) {
Justin Terry (VM)19306802018-01-22 13:07:49 -08001682 if (whpx_enabled()) {
1683 whpx_vcpu_kick(cpu);
1684 } else if (!QueueUserAPC(dummy_apc_func, cpu->hThread, 0)) {
Vincent Palatinb0cb0a62017-01-10 11:59:57 +01001685 fprintf(stderr, "%s: QueueUserAPC failed with error %lu\n",
1686 __func__, GetLastError());
1687 exit(1);
1688 }
1689 }
Paolo Bonzinicc015e92011-03-12 17:44:08 +01001690#endif
1691}
1692
Andreas Färberc08d7422012-05-03 04:34:15 +02001693void qemu_cpu_kick(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +00001694{
Andreas Färberf5c121b2012-05-03 01:22:49 +02001695 qemu_cond_broadcast(cpu->halt_cond);
Paolo Bonzinie0c38212015-08-26 00:19:19 +02001696 if (tcg_enabled()) {
Alex Bennée791158d2017-02-23 18:29:10 +00001697 cpu_exit(cpu);
Alex Bennée37257942017-02-23 18:29:14 +00001698 /* NOP unless doing single-thread RR */
Alex Bennée791158d2017-02-23 18:29:10 +00001699 qemu_cpu_kick_rr_cpu();
Paolo Bonzinie0c38212015-08-26 00:19:19 +02001700 } else {
Vincent Palatinb0cb0a62017-01-10 11:59:57 +01001701 if (hax_enabled()) {
1702 /*
1703 * FIXME: race condition with the exit_request check in
1704 * hax_vcpu_hax_exec
1705 */
1706 cpu->exit_request = 1;
1707 }
Paolo Bonzinie0c38212015-08-26 00:19:19 +02001708 qemu_cpu_kick_thread(cpu);
1709 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001710}
1711
Jan Kiszka46d62fa2011-02-01 22:15:59 +01001712void qemu_cpu_kick_self(void)
1713{
Andreas Färber4917cf42013-05-27 05:17:50 +02001714 assert(current_cpu);
Paolo Bonzini9102ded2015-08-18 06:52:09 -07001715 qemu_cpu_kick_thread(current_cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +00001716}
1717
Andreas Färber60e82572012-05-02 22:23:49 +02001718bool qemu_cpu_is_self(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +00001719{
Andreas Färber814e6122012-05-02 17:00:37 +02001720 return qemu_thread_is_self(cpu->thread);
Blue Swirl296af7c2010-03-29 19:23:50 +00001721}
1722
Paolo Bonzini79e2b9a2015-01-21 12:09:14 +01001723bool qemu_in_vcpu_thread(void)
Juan Quintelaaa723c22012-09-18 16:30:11 +02001724{
Andreas Färber4917cf42013-05-27 05:17:50 +02001725 return current_cpu && qemu_cpu_is_self(current_cpu);
Juan Quintelaaa723c22012-09-18 16:30:11 +02001726}
1727
Paolo Bonziniafbe7052015-06-18 18:47:19 +02001728static __thread bool iothread_locked = false;
1729
1730bool qemu_mutex_iothread_locked(void)
1731{
1732 return iothread_locked;
1733}
1734
Blue Swirl296af7c2010-03-29 19:23:50 +00001735void qemu_mutex_lock_iothread(void)
1736{
Jan Kiszka8d04fb52017-02-23 18:29:11 +00001737 g_assert(!qemu_mutex_iothread_locked());
1738 qemu_mutex_lock(&qemu_global_mutex);
Paolo Bonziniafbe7052015-06-18 18:47:19 +02001739 iothread_locked = true;
Blue Swirl296af7c2010-03-29 19:23:50 +00001740}
1741
1742void qemu_mutex_unlock_iothread(void)
1743{
Jan Kiszka8d04fb52017-02-23 18:29:11 +00001744 g_assert(qemu_mutex_iothread_locked());
Paolo Bonziniafbe7052015-06-18 18:47:19 +02001745 iothread_locked = false;
Blue Swirl296af7c2010-03-29 19:23:50 +00001746 qemu_mutex_unlock(&qemu_global_mutex);
1747}
1748
Alex Bennéee8faee02016-10-27 16:09:58 +01001749static bool all_vcpus_paused(void)
Blue Swirl296af7c2010-03-29 19:23:50 +00001750{
Andreas Färberbdc44642013-06-24 23:50:24 +02001751 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +00001752
Andreas Färberbdc44642013-06-24 23:50:24 +02001753 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +02001754 if (!cpu->stopped) {
Alex Bennéee8faee02016-10-27 16:09:58 +01001755 return false;
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001756 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001757 }
1758
Alex Bennéee8faee02016-10-27 16:09:58 +01001759 return true;
Blue Swirl296af7c2010-03-29 19:23:50 +00001760}
1761
1762void pause_all_vcpus(void)
1763{
Andreas Färberbdc44642013-06-24 23:50:24 +02001764 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +00001765
Alex Bligh40daca52013-08-21 16:03:02 +01001766 qemu_clock_enable(QEMU_CLOCK_VIRTUAL, false);
Andreas Färberbdc44642013-06-24 23:50:24 +02001767 CPU_FOREACH(cpu) {
David Hildenbrandebd05fe2017-11-29 20:12:15 +01001768 if (qemu_cpu_is_self(cpu)) {
1769 qemu_cpu_stop(cpu, true);
1770 } else {
1771 cpu->stop = true;
1772 qemu_cpu_kick(cpu);
1773 }
Jan Kiszkad798e972012-02-17 18:31:16 +01001774 }
1775
Blue Swirl296af7c2010-03-29 19:23:50 +00001776 while (!all_vcpus_paused()) {
Paolo Bonzinibe7d6c52011-03-12 17:44:02 +01001777 qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
Andreas Färberbdc44642013-06-24 23:50:24 +02001778 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +02001779 qemu_cpu_kick(cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +00001780 }
1781 }
1782}
1783
Igor Mammedov29936832013-04-23 10:29:37 +02001784void cpu_resume(CPUState *cpu)
1785{
1786 cpu->stop = false;
1787 cpu->stopped = false;
1788 qemu_cpu_kick(cpu);
1789}
1790
Blue Swirl296af7c2010-03-29 19:23:50 +00001791void resume_all_vcpus(void)
1792{
Andreas Färberbdc44642013-06-24 23:50:24 +02001793 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +00001794
Alex Bligh40daca52013-08-21 16:03:02 +01001795 qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
Andreas Färberbdc44642013-06-24 23:50:24 +02001796 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +02001797 cpu_resume(cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +00001798 }
1799}
1800
Paolo Bonzinidbadee42018-01-30 16:40:12 +01001801void cpu_remove_sync(CPUState *cpu)
Gu Zheng4c055ab2016-05-12 09:18:13 +05301802{
1803 cpu->stop = true;
1804 cpu->unplug = true;
1805 qemu_cpu_kick(cpu);
Paolo Bonzinidbadee42018-01-30 16:40:12 +01001806 qemu_mutex_unlock_iothread();
1807 qemu_thread_join(cpu->thread);
1808 qemu_mutex_lock_iothread();
Bharata B Rao2c579042016-05-12 09:18:14 +05301809}
1810
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001811/* For temporary buffers for forming a name */
1812#define VCPU_THREAD_NAME_SIZE 16
1813
Andreas Färbere5ab30a2012-05-03 01:50:44 +02001814static void qemu_tcg_init_vcpu(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +00001815{
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001816 char thread_name[VCPU_THREAD_NAME_SIZE];
Alex Bennée37257942017-02-23 18:29:14 +00001817 static QemuCond *single_tcg_halt_cond;
1818 static QemuThread *single_tcg_cpu_thread;
Emilio G. Cotae8feb962017-07-07 19:24:20 -04001819 static int tcg_region_inited;
1820
1821 /*
1822 * Initialize TCG regions--once. Now is a good time, because:
1823 * (1) TCG's init context, prologue and target globals have been set up.
1824 * (2) qemu_tcg_mttcg_enabled() works now (TCG init code runs before the
1825 * -accel flag is processed, so the check doesn't work then).
1826 */
1827 if (!tcg_region_inited) {
1828 tcg_region_inited = 1;
1829 tcg_region_init();
1830 }
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001831
Alex Bennée37257942017-02-23 18:29:14 +00001832 if (qemu_tcg_mttcg_enabled() || !single_tcg_cpu_thread) {
Andreas Färber814e6122012-05-02 17:00:37 +02001833 cpu->thread = g_malloc0(sizeof(QemuThread));
Andreas Färberf5c121b2012-05-03 01:22:49 +02001834 cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1835 qemu_cond_init(cpu->halt_cond);
Alex Bennée37257942017-02-23 18:29:14 +00001836
1837 if (qemu_tcg_mttcg_enabled()) {
1838 /* create a thread per vCPU with TCG (MTTCG) */
1839 parallel_cpus = true;
1840 snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/TCG",
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001841 cpu->cpu_index);
Alex Bennée37257942017-02-23 18:29:14 +00001842
1843 qemu_thread_create(cpu->thread, thread_name, qemu_tcg_cpu_thread_fn,
1844 cpu, QEMU_THREAD_JOINABLE);
1845
1846 } else {
1847 /* share a single thread for all cpus with TCG */
1848 snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "ALL CPUs/TCG");
1849 qemu_thread_create(cpu->thread, thread_name,
1850 qemu_tcg_rr_cpu_thread_fn,
1851 cpu, QEMU_THREAD_JOINABLE);
1852
1853 single_tcg_halt_cond = cpu->halt_cond;
1854 single_tcg_cpu_thread = cpu->thread;
1855 }
Paolo Bonzini1ecf47b2011-12-13 13:43:52 +01001856#ifdef _WIN32
Andreas Färber814e6122012-05-02 17:00:37 +02001857 cpu->hThread = qemu_thread_get_handle(cpu->thread);
Paolo Bonzini1ecf47b2011-12-13 13:43:52 +01001858#endif
Andreas Färber61a46212012-05-02 22:49:36 +02001859 while (!cpu->created) {
Paolo Bonzini18a85722011-03-12 17:44:03 +01001860 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001861 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001862 } else {
Alex Bennée37257942017-02-23 18:29:14 +00001863 /* For non-MTTCG cases we share the thread */
1864 cpu->thread = single_tcg_cpu_thread;
1865 cpu->halt_cond = single_tcg_halt_cond;
Blue Swirl296af7c2010-03-29 19:23:50 +00001866 }
1867}
1868
Vincent Palatinb0cb0a62017-01-10 11:59:57 +01001869static void qemu_hax_start_vcpu(CPUState *cpu)
1870{
1871 char thread_name[VCPU_THREAD_NAME_SIZE];
1872
1873 cpu->thread = g_malloc0(sizeof(QemuThread));
1874 cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1875 qemu_cond_init(cpu->halt_cond);
1876
1877 snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/HAX",
1878 cpu->cpu_index);
1879 qemu_thread_create(cpu->thread, thread_name, qemu_hax_cpu_thread_fn,
1880 cpu, QEMU_THREAD_JOINABLE);
1881#ifdef _WIN32
1882 cpu->hThread = qemu_thread_get_handle(cpu->thread);
1883#endif
1884 while (!cpu->created) {
1885 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1886 }
1887}
1888
Andreas Färber48a106b2013-05-27 02:20:39 +02001889static void qemu_kvm_start_vcpu(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +00001890{
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001891 char thread_name[VCPU_THREAD_NAME_SIZE];
1892
Andreas Färber814e6122012-05-02 17:00:37 +02001893 cpu->thread = g_malloc0(sizeof(QemuThread));
Andreas Färberf5c121b2012-05-03 01:22:49 +02001894 cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1895 qemu_cond_init(cpu->halt_cond);
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001896 snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/KVM",
1897 cpu->cpu_index);
1898 qemu_thread_create(cpu->thread, thread_name, qemu_kvm_cpu_thread_fn,
1899 cpu, QEMU_THREAD_JOINABLE);
Andreas Färber61a46212012-05-02 22:49:36 +02001900 while (!cpu->created) {
Paolo Bonzini18a85722011-03-12 17:44:03 +01001901 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001902 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001903}
1904
Sergio Andres Gomez Del Realc97d6d22017-09-13 04:05:09 -05001905static void qemu_hvf_start_vcpu(CPUState *cpu)
1906{
1907 char thread_name[VCPU_THREAD_NAME_SIZE];
1908
1909 /* HVF currently does not support TCG, and only runs in
1910 * unrestricted-guest mode. */
1911 assert(hvf_enabled());
1912
1913 cpu->thread = g_malloc0(sizeof(QemuThread));
1914 cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1915 qemu_cond_init(cpu->halt_cond);
1916
1917 snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/HVF",
1918 cpu->cpu_index);
1919 qemu_thread_create(cpu->thread, thread_name, qemu_hvf_cpu_thread_fn,
1920 cpu, QEMU_THREAD_JOINABLE);
1921 while (!cpu->created) {
1922 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1923 }
1924}
1925
Justin Terry (VM)19306802018-01-22 13:07:49 -08001926static void qemu_whpx_start_vcpu(CPUState *cpu)
1927{
1928 char thread_name[VCPU_THREAD_NAME_SIZE];
1929
1930 cpu->thread = g_malloc0(sizeof(QemuThread));
1931 cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1932 qemu_cond_init(cpu->halt_cond);
1933 snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/WHPX",
1934 cpu->cpu_index);
1935 qemu_thread_create(cpu->thread, thread_name, qemu_whpx_cpu_thread_fn,
1936 cpu, QEMU_THREAD_JOINABLE);
1937#ifdef _WIN32
1938 cpu->hThread = qemu_thread_get_handle(cpu->thread);
1939#endif
1940 while (!cpu->created) {
1941 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1942 }
1943}
1944
Andreas Färber10a90212013-05-27 02:24:35 +02001945static void qemu_dummy_start_vcpu(CPUState *cpu)
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001946{
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001947 char thread_name[VCPU_THREAD_NAME_SIZE];
1948
Andreas Färber814e6122012-05-02 17:00:37 +02001949 cpu->thread = g_malloc0(sizeof(QemuThread));
Andreas Färberf5c121b2012-05-03 01:22:49 +02001950 cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1951 qemu_cond_init(cpu->halt_cond);
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001952 snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/DUMMY",
1953 cpu->cpu_index);
1954 qemu_thread_create(cpu->thread, thread_name, qemu_dummy_cpu_thread_fn, cpu,
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001955 QEMU_THREAD_JOINABLE);
Andreas Färber61a46212012-05-02 22:49:36 +02001956 while (!cpu->created) {
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001957 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1958 }
1959}
1960
Andreas Färberc643bed2013-05-27 03:23:24 +02001961void qemu_init_vcpu(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +00001962{
Andreas Färberce3960e2012-12-17 03:27:07 +01001963 cpu->nr_cores = smp_cores;
1964 cpu->nr_threads = smp_threads;
Andreas Färberf324e762012-05-02 23:26:21 +02001965 cpu->stopped = true;
Peter Maydell56943e82016-01-21 14:15:04 +00001966
1967 if (!cpu->as) {
1968 /* If the target cpu hasn't set up any address spaces itself,
1969 * give it the default one.
1970 */
Peter Maydell12ebc9a2016-01-21 14:15:04 +00001971 cpu->num_ases = 1;
Peter Xu80ceb072017-11-23 17:23:32 +08001972 cpu_address_space_init(cpu, 0, "cpu-memory", cpu->memory);
Peter Maydell56943e82016-01-21 14:15:04 +00001973 }
1974
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001975 if (kvm_enabled()) {
Andreas Färber48a106b2013-05-27 02:20:39 +02001976 qemu_kvm_start_vcpu(cpu);
Vincent Palatinb0cb0a62017-01-10 11:59:57 +01001977 } else if (hax_enabled()) {
1978 qemu_hax_start_vcpu(cpu);
Sergio Andres Gomez Del Realc97d6d22017-09-13 04:05:09 -05001979 } else if (hvf_enabled()) {
1980 qemu_hvf_start_vcpu(cpu);
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001981 } else if (tcg_enabled()) {
Andreas Färbere5ab30a2012-05-03 01:50:44 +02001982 qemu_tcg_init_vcpu(cpu);
Justin Terry (VM)19306802018-01-22 13:07:49 -08001983 } else if (whpx_enabled()) {
1984 qemu_whpx_start_vcpu(cpu);
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001985 } else {
Andreas Färber10a90212013-05-27 02:24:35 +02001986 qemu_dummy_start_vcpu(cpu);
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001987 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001988}
1989
Jan Kiszkab4a3d962011-02-01 22:15:43 +01001990void cpu_stop_current(void)
Blue Swirl296af7c2010-03-29 19:23:50 +00001991{
Andreas Färber4917cf42013-05-27 05:17:50 +02001992 if (current_cpu) {
David Hildenbrandebd05fe2017-11-29 20:12:15 +01001993 qemu_cpu_stop(current_cpu, true);
Jan Kiszkab4a3d962011-02-01 22:15:43 +01001994 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001995}
1996
Kevin Wolf56983462013-07-05 13:49:54 +02001997int vm_stop(RunState state)
Blue Swirl296af7c2010-03-29 19:23:50 +00001998{
Juan Quintelaaa723c22012-09-18 16:30:11 +02001999 if (qemu_in_vcpu_thread()) {
Paolo Bonzini74892d22014-06-05 14:53:58 +02002000 qemu_system_vmstop_request_prepare();
Luiz Capitulino1dfb4dd2011-07-29 14:26:33 -03002001 qemu_system_vmstop_request(state);
Blue Swirl296af7c2010-03-29 19:23:50 +00002002 /*
2003 * FIXME: should not return to device code in case
2004 * vm_stop() has been requested.
2005 */
Jan Kiszkab4a3d962011-02-01 22:15:43 +01002006 cpu_stop_current();
Kevin Wolf56983462013-07-05 13:49:54 +02002007 return 0;
Blue Swirl296af7c2010-03-29 19:23:50 +00002008 }
Kevin Wolf56983462013-07-05 13:49:54 +02002009
2010 return do_vm_stop(state);
Blue Swirl296af7c2010-03-29 19:23:50 +00002011}
2012
Claudio Imbrenda2d76e822017-02-14 18:07:47 +01002013/**
2014 * Prepare for (re)starting the VM.
2015 * Returns -1 if the vCPUs are not to be restarted (e.g. if they are already
2016 * running or in case of an error condition), 0 otherwise.
2017 */
2018int vm_prepare_start(void)
2019{
2020 RunState requested;
2021 int res = 0;
2022
2023 qemu_vmstop_requested(&requested);
2024 if (runstate_is_running() && requested == RUN_STATE__MAX) {
2025 return -1;
2026 }
2027
2028 /* Ensure that a STOP/RESUME pair of events is emitted if a
2029 * vmstop request was pending. The BLOCK_IO_ERROR event, for
2030 * example, according to documentation is always followed by
2031 * the STOP event.
2032 */
2033 if (runstate_is_running()) {
2034 qapi_event_send_stop(&error_abort);
2035 res = -1;
2036 } else {
2037 replay_enable_events();
2038 cpu_enable_ticks();
2039 runstate_set(RUN_STATE_RUNNING);
2040 vm_state_notify(1, RUN_STATE_RUNNING);
2041 }
2042
2043 /* We are sending this now, but the CPUs will be resumed shortly later */
2044 qapi_event_send_resume(&error_abort);
2045 return res;
2046}
2047
2048void vm_start(void)
2049{
2050 if (!vm_prepare_start()) {
2051 resume_all_vcpus();
2052 }
2053}
2054
Luiz Capitulino8a9236f2011-10-14 11:18:09 -03002055/* does a state transition even if the VM is already stopped,
2056 current state is forgotten forever */
Kevin Wolf56983462013-07-05 13:49:54 +02002057int vm_stop_force_state(RunState state)
Luiz Capitulino8a9236f2011-10-14 11:18:09 -03002058{
2059 if (runstate_is_running()) {
Kevin Wolf56983462013-07-05 13:49:54 +02002060 return vm_stop(state);
Luiz Capitulino8a9236f2011-10-14 11:18:09 -03002061 } else {
2062 runstate_set(state);
Wen Congyangb2780d32015-11-20 17:34:38 +08002063
2064 bdrv_drain_all();
Kevin Wolf594a45c2013-07-18 14:52:19 +02002065 /* Make sure to return an error if the flush in a previous vm_stop()
2066 * failed. */
John Snow22af08e2016-09-22 21:45:51 -04002067 return bdrv_flush_all();
Luiz Capitulino8a9236f2011-10-14 11:18:09 -03002068 }
2069}
2070
Stefan Weil9a78eea2010-10-22 23:03:33 +02002071void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
Blue Swirl262353c2010-05-04 19:55:35 +00002072{
2073 /* XXX: implement xxx_cpu_list for targets that still miss it */
Peter Maydelle916cbf2012-09-05 17:41:08 -03002074#if defined(cpu_list)
2075 cpu_list(f, cpu_fprintf);
Blue Swirl262353c2010-05-04 19:55:35 +00002076#endif
2077}
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03002078
2079CpuInfoList *qmp_query_cpus(Error **errp)
2080{
Igor Mammedovafed5a52017-05-10 13:29:55 +02002081 MachineState *ms = MACHINE(qdev_get_machine());
2082 MachineClass *mc = MACHINE_GET_CLASS(ms);
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03002083 CpuInfoList *head = NULL, *cur_item = NULL;
Andreas Färber182735e2013-05-29 22:29:20 +02002084 CPUState *cpu;
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03002085
Andreas Färberbdc44642013-06-24 23:50:24 +02002086 CPU_FOREACH(cpu) {
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03002087 CpuInfoList *info;
Andreas Färber182735e2013-05-29 22:29:20 +02002088#if defined(TARGET_I386)
2089 X86CPU *x86_cpu = X86_CPU(cpu);
2090 CPUX86State *env = &x86_cpu->env;
2091#elif defined(TARGET_PPC)
2092 PowerPCCPU *ppc_cpu = POWERPC_CPU(cpu);
2093 CPUPPCState *env = &ppc_cpu->env;
2094#elif defined(TARGET_SPARC)
2095 SPARCCPU *sparc_cpu = SPARC_CPU(cpu);
2096 CPUSPARCState *env = &sparc_cpu->env;
2097#elif defined(TARGET_MIPS)
2098 MIPSCPU *mips_cpu = MIPS_CPU(cpu);
2099 CPUMIPSState *env = &mips_cpu->env;
Bastian Koppelmann48e06fe2014-09-01 12:59:46 +01002100#elif defined(TARGET_TRICORE)
2101 TriCoreCPU *tricore_cpu = TRICORE_CPU(cpu);
2102 CPUTriCoreState *env = &tricore_cpu->env;
Andreas Färber182735e2013-05-29 22:29:20 +02002103#endif
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03002104
Andreas Färbercb446ec2013-05-01 14:24:52 +02002105 cpu_synchronize_state(cpu);
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03002106
2107 info = g_malloc0(sizeof(*info));
2108 info->value = g_malloc0(sizeof(*info->value));
Andreas Färber55e5c282012-12-17 06:18:02 +01002109 info->value->CPU = cpu->cpu_index;
Andreas Färber182735e2013-05-29 22:29:20 +02002110 info->value->current = (cpu == first_cpu);
Andreas Färber259186a2013-01-17 18:51:17 +01002111 info->value->halted = cpu->halted;
Eduardo Habkost58f88d42015-05-08 16:04:22 -03002112 info->value->qom_path = object_get_canonical_path(OBJECT(cpu));
Andreas Färber9f09e182012-05-03 06:59:07 +02002113 info->value->thread_id = cpu->thread_id;
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03002114#if defined(TARGET_I386)
Eric Blake86f4b682015-11-18 01:52:59 -07002115 info->value->arch = CPU_INFO_ARCH_X86;
Eric Blake544a3732016-02-17 23:48:27 -07002116 info->value->u.x86.pc = env->eip + env->segs[R_CS].base;
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03002117#elif defined(TARGET_PPC)
Eric Blake86f4b682015-11-18 01:52:59 -07002118 info->value->arch = CPU_INFO_ARCH_PPC;
Eric Blake544a3732016-02-17 23:48:27 -07002119 info->value->u.ppc.nip = env->nip;
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03002120#elif defined(TARGET_SPARC)
Eric Blake86f4b682015-11-18 01:52:59 -07002121 info->value->arch = CPU_INFO_ARCH_SPARC;
Eric Blake544a3732016-02-17 23:48:27 -07002122 info->value->u.q_sparc.pc = env->pc;
2123 info->value->u.q_sparc.npc = env->npc;
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03002124#elif defined(TARGET_MIPS)
Eric Blake86f4b682015-11-18 01:52:59 -07002125 info->value->arch = CPU_INFO_ARCH_MIPS;
Eric Blake544a3732016-02-17 23:48:27 -07002126 info->value->u.q_mips.PC = env->active_tc.PC;
Bastian Koppelmann48e06fe2014-09-01 12:59:46 +01002127#elif defined(TARGET_TRICORE)
Eric Blake86f4b682015-11-18 01:52:59 -07002128 info->value->arch = CPU_INFO_ARCH_TRICORE;
Eric Blake544a3732016-02-17 23:48:27 -07002129 info->value->u.tricore.PC = env->PC;
Eric Blake86f4b682015-11-18 01:52:59 -07002130#else
2131 info->value->arch = CPU_INFO_ARCH_OTHER;
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03002132#endif
Igor Mammedovafed5a52017-05-10 13:29:55 +02002133 info->value->has_props = !!mc->cpu_index_to_instance_props;
2134 if (info->value->has_props) {
2135 CpuInstanceProperties *props;
2136 props = g_malloc0(sizeof(*props));
2137 *props = mc->cpu_index_to_instance_props(ms, cpu->cpu_index);
2138 info->value->props = props;
2139 }
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03002140
2141 /* XXX: waiting for the qapi to support GSList */
2142 if (!cur_item) {
2143 head = cur_item = info;
2144 } else {
2145 cur_item->next = info;
2146 cur_item = info;
2147 }
2148 }
2149
2150 return head;
2151}
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02002152
2153void qmp_memsave(int64_t addr, int64_t size, const char *filename,
2154 bool has_cpu, int64_t cpu_index, Error **errp)
2155{
2156 FILE *f;
2157 uint32_t l;
Andreas Färber55e5c282012-12-17 06:18:02 +01002158 CPUState *cpu;
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02002159 uint8_t buf[1024];
Borislav Petkov0dc9daf2015-02-08 13:14:38 +01002160 int64_t orig_addr = addr, orig_size = size;
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02002161
2162 if (!has_cpu) {
2163 cpu_index = 0;
2164 }
2165
Andreas Färber151d1322013-02-15 15:41:49 +01002166 cpu = qemu_get_cpu(cpu_index);
2167 if (cpu == NULL) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01002168 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
2169 "a CPU number");
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02002170 return;
2171 }
2172
2173 f = fopen(filename, "wb");
2174 if (!f) {
Luiz Capitulino618da852013-06-07 14:35:06 -04002175 error_setg_file_open(errp, errno, filename);
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02002176 return;
2177 }
2178
2179 while (size != 0) {
2180 l = sizeof(buf);
2181 if (l > size)
2182 l = size;
Aneesh Kumar K.V2f4d0f52013-10-01 21:49:30 +05302183 if (cpu_memory_rw_debug(cpu, addr, buf, l, 0) != 0) {
Borislav Petkov0dc9daf2015-02-08 13:14:38 +01002184 error_setg(errp, "Invalid addr 0x%016" PRIx64 "/size %" PRId64
2185 " specified", orig_addr, orig_size);
Aneesh Kumar K.V2f4d0f52013-10-01 21:49:30 +05302186 goto exit;
2187 }
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02002188 if (fwrite(buf, 1, l, f) != l) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01002189 error_setg(errp, QERR_IO_ERROR);
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02002190 goto exit;
2191 }
2192 addr += l;
2193 size -= l;
2194 }
2195
2196exit:
2197 fclose(f);
2198}
Luiz Capitulino6d3962b2011-11-22 17:26:46 -02002199
2200void qmp_pmemsave(int64_t addr, int64_t size, const char *filename,
2201 Error **errp)
2202{
2203 FILE *f;
2204 uint32_t l;
2205 uint8_t buf[1024];
2206
2207 f = fopen(filename, "wb");
2208 if (!f) {
Luiz Capitulino618da852013-06-07 14:35:06 -04002209 error_setg_file_open(errp, errno, filename);
Luiz Capitulino6d3962b2011-11-22 17:26:46 -02002210 return;
2211 }
2212
2213 while (size != 0) {
2214 l = sizeof(buf);
2215 if (l > size)
2216 l = size;
Stefan Weileb6282f2014-04-07 20:28:23 +02002217 cpu_physical_memory_read(addr, buf, l);
Luiz Capitulino6d3962b2011-11-22 17:26:46 -02002218 if (fwrite(buf, 1, l, f) != l) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01002219 error_setg(errp, QERR_IO_ERROR);
Luiz Capitulino6d3962b2011-11-22 17:26:46 -02002220 goto exit;
2221 }
2222 addr += l;
2223 size -= l;
2224 }
2225
2226exit:
2227 fclose(f);
2228}
Luiz Capitulinoab49ab52011-11-23 12:55:53 -02002229
2230void qmp_inject_nmi(Error **errp)
2231{
Alexey Kardashevskiy9cb805f2014-08-20 22:16:33 +10002232 nmi_monitor_handle(monitor_get_cpu_index(), errp);
Luiz Capitulinoab49ab52011-11-23 12:55:53 -02002233}
Sebastian Tanase27498be2014-07-25 11:56:33 +02002234
2235void dump_drift_info(FILE *f, fprintf_function cpu_fprintf)
2236{
2237 if (!use_icount) {
2238 return;
2239 }
2240
2241 cpu_fprintf(f, "Host - Guest clock %"PRIi64" ms\n",
2242 (cpu_get_clock() - cpu_get_icount())/SCALE_MS);
2243 if (icount_align_option) {
2244 cpu_fprintf(f, "Max guest delay %"PRIi64" ms\n", -max_delay/SCALE_MS);
2245 cpu_fprintf(f, "Max guest advance %"PRIi64" ms\n", max_advance/SCALE_MS);
2246 } else {
2247 cpu_fprintf(f, "Max guest delay NA\n");
2248 cpu_fprintf(f, "Max guest advance NA\n");
2249 }
2250}