blob: fc78502ce5f747b3eb9b05d5330a0a8ec882ce50 [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
25/* Needed early for CONFIG_BSD etc. */
Peter Maydell7b31bbc2016-01-26 18:16:56 +000026#include "qemu/osdep.h"
Paolo Bonzini33c11872016-03-15 16:58:45 +010027#include "qemu-common.h"
28#include "cpu.h"
Paolo Bonzini83c90892012-12-17 18:19:49 +010029#include "monitor/monitor.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"
Luiz Capitulinode0b36b2011-09-21 16:38:35 -030038#include "qmp-commands.h"
Paolo Bonzini63c91552016-03-15 13:18:37 +010039#include "exec/exec-all.h"
Blue Swirl296af7c2010-03-29 19:23:50 +000040
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010041#include "qemu/thread.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010042#include "sysemu/cpus.h"
43#include "sysemu/qtest.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010044#include "qemu/main-loop.h"
45#include "qemu/bitmap.h"
Liu Ping Fancb365642013-09-25 14:20:58 +080046#include "qemu/seqlock.h"
Wenchao Xiaa4e15de2014-06-18 08:43:36 +020047#include "qapi-event.h"
Alexey Kardashevskiy9cb805f2014-08-20 22:16:33 +100048#include "hw/nmi.h"
Pavel Dovgalyuk8b427042015-09-17 19:24:05 +030049#include "sysemu/replay.h"
Jan Kiszka0ff0fc12011-06-23 10:15:55 +020050
51#ifndef _WIN32
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010052#include "qemu/compatfd.h"
Jan Kiszka0ff0fc12011-06-23 10:15:55 +020053#endif
Blue Swirl296af7c2010-03-29 19:23:50 +000054
Jan Kiszka6d9cb732011-02-01 22:15:58 +010055#ifdef CONFIG_LINUX
56
57#include <sys/prctl.h>
58
Marcelo Tosattic0532a72010-10-11 15:31:21 -030059#ifndef PR_MCE_KILL
60#define PR_MCE_KILL 33
61#endif
62
Jan Kiszka6d9cb732011-02-01 22:15:58 +010063#ifndef PR_MCE_KILL_SET
64#define PR_MCE_KILL_SET 1
65#endif
66
67#ifndef PR_MCE_KILL_EARLY
68#define PR_MCE_KILL_EARLY 1
69#endif
70
71#endif /* CONFIG_LINUX */
72
Sebastian Tanase27498be2014-07-25 11:56:33 +020073int64_t max_delay;
74int64_t max_advance;
Blue Swirl296af7c2010-03-29 19:23:50 +000075
Jason J. Herne2adcc852015-09-08 13:12:33 -040076/* vcpu throttling controls */
77static QEMUTimer *throttle_timer;
78static unsigned int throttle_percentage;
79
80#define CPU_THROTTLE_PCT_MIN 1
81#define CPU_THROTTLE_PCT_MAX 99
82#define CPU_THROTTLE_TIMESLICE_NS 10000000
83
Tiejun Chen321bc0b2013-08-02 09:43:09 +080084bool cpu_is_stopped(CPUState *cpu)
85{
86 return cpu->stopped || !runstate_is_running();
87}
88
Andreas Färbera98ae1d2013-05-26 23:21:08 +020089static bool cpu_thread_is_idle(CPUState *cpu)
Peter Maydellac873f12012-07-19 16:52:27 +010090{
Andreas Färberc64ca812012-05-03 02:11:45 +020091 if (cpu->stop || cpu->queued_work_first) {
Peter Maydellac873f12012-07-19 16:52:27 +010092 return false;
93 }
Tiejun Chen321bc0b2013-08-02 09:43:09 +080094 if (cpu_is_stopped(cpu)) {
Peter Maydellac873f12012-07-19 16:52:27 +010095 return true;
96 }
Andreas Färber8c2e1b02013-08-25 18:53:55 +020097 if (!cpu->halted || cpu_has_work(cpu) ||
Alexander Graf215e79c2013-04-24 22:24:12 +020098 kvm_halt_in_kernel()) {
Peter Maydellac873f12012-07-19 16:52:27 +010099 return false;
100 }
101 return true;
102}
103
104static bool all_cpu_threads_idle(void)
105{
Andreas Färber182735e2013-05-29 22:29:20 +0200106 CPUState *cpu;
Peter Maydellac873f12012-07-19 16:52:27 +0100107
Andreas Färberbdc44642013-06-24 23:50:24 +0200108 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +0200109 if (!cpu_thread_is_idle(cpu)) {
Peter Maydellac873f12012-07-19 16:52:27 +0100110 return false;
111 }
112 }
113 return true;
114}
115
Blue Swirl296af7c2010-03-29 19:23:50 +0000116/***********************************************************/
Paolo Bonzini946fb272011-09-12 13:57:37 +0200117/* guest cycle counter */
118
Paolo Bonzinia3270e12013-10-07 17:18:15 +0200119/* Protected by TimersState seqlock */
120
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200121static bool icount_sleep = true;
Sebastian Tanase71468392014-07-23 11:47:50 +0200122static int64_t vm_clock_warp_start = -1;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200123/* Conversion factor from emulated instructions to virtual clock ticks. */
124static int icount_time_shift;
125/* Arbitrarily pick 1MIPS as the minimum allowable speed. */
126#define MAX_ICOUNT_SHIFT 10
Paolo Bonzinia3270e12013-10-07 17:18:15 +0200127
Paolo Bonzini946fb272011-09-12 13:57:37 +0200128static QEMUTimer *icount_rt_timer;
129static QEMUTimer *icount_vm_timer;
130static QEMUTimer *icount_warp_timer;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200131
132typedef struct TimersState {
Liu Ping Fancb365642013-09-25 14:20:58 +0800133 /* Protected by BQL. */
Paolo Bonzini946fb272011-09-12 13:57:37 +0200134 int64_t cpu_ticks_prev;
135 int64_t cpu_ticks_offset;
Liu Ping Fancb365642013-09-25 14:20:58 +0800136
137 /* cpu_clock_offset can be read out of BQL, so protect it with
138 * this lock.
139 */
140 QemuSeqLock vm_clock_seqlock;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200141 int64_t cpu_clock_offset;
142 int32_t cpu_ticks_enabled;
143 int64_t dummy;
KONRAD Fredericc96778b2014-08-01 01:37:09 +0200144
145 /* Compensate for varying guest execution speed. */
146 int64_t qemu_icount_bias;
147 /* Only written by TCG thread */
148 int64_t qemu_icount;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200149} TimersState;
150
Liu Ping Fand9cd4002013-07-21 08:43:00 +0000151static TimersState timers_state;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200152
Pavel Dovgalyuk2a629142014-12-08 10:53:45 +0300153int64_t cpu_get_icount_raw(void)
Paolo Bonzini946fb272011-09-12 13:57:37 +0200154{
155 int64_t icount;
Andreas Färber4917cf42013-05-27 05:17:50 +0200156 CPUState *cpu = current_cpu;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200157
KONRAD Fredericc96778b2014-08-01 01:37:09 +0200158 icount = timers_state.qemu_icount;
Andreas Färber4917cf42013-05-27 05:17:50 +0200159 if (cpu) {
Paolo Bonzini414b15c2015-06-24 14:16:26 +0200160 if (!cpu->can_do_io) {
Pavel Dovgalyuk2a629142014-12-08 10:53:45 +0300161 fprintf(stderr, "Bad icount read\n");
162 exit(1);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200163 }
Andreas Färber28ecfd72013-08-26 05:51:49 +0200164 icount -= (cpu->icount_decr.u16.low + cpu->icount_extra);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200165 }
Pavel Dovgalyuk2a629142014-12-08 10:53:45 +0300166 return icount;
167}
168
169/* Return the virtual CPU time, based on the instruction counter. */
170static int64_t cpu_get_icount_locked(void)
171{
172 int64_t icount = cpu_get_icount_raw();
KONRAD Frederic3f031312014-08-01 01:37:15 +0200173 return timers_state.qemu_icount_bias + cpu_icount_to_ns(icount);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200174}
175
Paolo Bonzini17a15f12013-10-03 15:17:25 +0200176int64_t cpu_get_icount(void)
177{
178 int64_t icount;
179 unsigned start;
180
181 do {
182 start = seqlock_read_begin(&timers_state.vm_clock_seqlock);
183 icount = cpu_get_icount_locked();
184 } while (seqlock_read_retry(&timers_state.vm_clock_seqlock, start));
185
186 return icount;
187}
188
KONRAD Frederic3f031312014-08-01 01:37:15 +0200189int64_t cpu_icount_to_ns(int64_t icount)
190{
191 return icount << icount_time_shift;
192}
193
Cao jind90f3cc2016-07-29 19:05:38 +0800194/* return the time elapsed in VM between vm_start and vm_stop. Unless
195 * icount is active, cpu_get_ticks() uses units of the host CPU cycle
196 * counter.
197 *
198 * Caller must hold the BQL
199 */
Paolo Bonzini946fb272011-09-12 13:57:37 +0200200int64_t cpu_get_ticks(void)
201{
Paolo Bonzini5f3e3102013-10-28 17:32:18 +0100202 int64_t ticks;
203
Paolo Bonzini946fb272011-09-12 13:57:37 +0200204 if (use_icount) {
205 return cpu_get_icount();
206 }
Paolo Bonzini5f3e3102013-10-28 17:32:18 +0100207
208 ticks = timers_state.cpu_ticks_offset;
209 if (timers_state.cpu_ticks_enabled) {
Christopher Covington4a7428c2015-09-25 10:42:21 -0400210 ticks += cpu_get_host_ticks();
Paolo Bonzini946fb272011-09-12 13:57:37 +0200211 }
Paolo Bonzini5f3e3102013-10-28 17:32:18 +0100212
213 if (timers_state.cpu_ticks_prev > ticks) {
214 /* Note: non increasing ticks may happen if the host uses
215 software suspend */
216 timers_state.cpu_ticks_offset += timers_state.cpu_ticks_prev - ticks;
217 ticks = timers_state.cpu_ticks_prev;
218 }
219
220 timers_state.cpu_ticks_prev = ticks;
221 return ticks;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200222}
223
Liu Ping Fancb365642013-09-25 14:20:58 +0800224static int64_t cpu_get_clock_locked(void)
225{
Cao jin1d45cea2016-07-29 19:05:37 +0800226 int64_t time;
Liu Ping Fancb365642013-09-25 14:20:58 +0800227
Cao jin1d45cea2016-07-29 19:05:37 +0800228 time = timers_state.cpu_clock_offset;
Paolo Bonzini5f3e3102013-10-28 17:32:18 +0100229 if (timers_state.cpu_ticks_enabled) {
Cao jin1d45cea2016-07-29 19:05:37 +0800230 time += get_clock();
Liu Ping Fancb365642013-09-25 14:20:58 +0800231 }
232
Cao jin1d45cea2016-07-29 19:05:37 +0800233 return time;
Liu Ping Fancb365642013-09-25 14:20:58 +0800234}
235
Cao jind90f3cc2016-07-29 19:05:38 +0800236/* Return the monotonic time elapsed in VM, i.e.,
Peter Maydell8212ff82016-09-15 10:24:22 +0100237 * the time between vm_start and vm_stop
238 */
Paolo Bonzini946fb272011-09-12 13:57:37 +0200239int64_t cpu_get_clock(void)
240{
241 int64_t ti;
Liu Ping Fancb365642013-09-25 14:20:58 +0800242 unsigned start;
243
244 do {
245 start = seqlock_read_begin(&timers_state.vm_clock_seqlock);
246 ti = cpu_get_clock_locked();
247 } while (seqlock_read_retry(&timers_state.vm_clock_seqlock, start));
248
249 return ti;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200250}
251
Liu Ping Fancb365642013-09-25 14:20:58 +0800252/* enable cpu_get_ticks()
Cao jin3224e872016-07-08 18:31:37 +0800253 * Caller must hold BQL which serves as mutex for vm_clock_seqlock.
Liu Ping Fancb365642013-09-25 14:20:58 +0800254 */
Paolo Bonzini946fb272011-09-12 13:57:37 +0200255void cpu_enable_ticks(void)
256{
Liu Ping Fancb365642013-09-25 14:20:58 +0800257 /* Here, the really thing protected by seqlock is cpu_clock_offset. */
Emilio G. Cota03719e42016-06-08 14:55:21 -0400258 seqlock_write_begin(&timers_state.vm_clock_seqlock);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200259 if (!timers_state.cpu_ticks_enabled) {
Christopher Covington4a7428c2015-09-25 10:42:21 -0400260 timers_state.cpu_ticks_offset -= cpu_get_host_ticks();
Paolo Bonzini946fb272011-09-12 13:57:37 +0200261 timers_state.cpu_clock_offset -= get_clock();
262 timers_state.cpu_ticks_enabled = 1;
263 }
Emilio G. Cota03719e42016-06-08 14:55:21 -0400264 seqlock_write_end(&timers_state.vm_clock_seqlock);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200265}
266
267/* disable cpu_get_ticks() : the clock is stopped. You must not call
Liu Ping Fancb365642013-09-25 14:20:58 +0800268 * cpu_get_ticks() after that.
Cao jin3224e872016-07-08 18:31:37 +0800269 * Caller must hold BQL which serves as mutex for vm_clock_seqlock.
Liu Ping Fancb365642013-09-25 14:20:58 +0800270 */
Paolo Bonzini946fb272011-09-12 13:57:37 +0200271void cpu_disable_ticks(void)
272{
Liu Ping Fancb365642013-09-25 14:20:58 +0800273 /* Here, the really thing protected by seqlock is cpu_clock_offset. */
Emilio G. Cota03719e42016-06-08 14:55:21 -0400274 seqlock_write_begin(&timers_state.vm_clock_seqlock);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200275 if (timers_state.cpu_ticks_enabled) {
Christopher Covington4a7428c2015-09-25 10:42:21 -0400276 timers_state.cpu_ticks_offset += cpu_get_host_ticks();
Liu Ping Fancb365642013-09-25 14:20:58 +0800277 timers_state.cpu_clock_offset = cpu_get_clock_locked();
Paolo Bonzini946fb272011-09-12 13:57:37 +0200278 timers_state.cpu_ticks_enabled = 0;
279 }
Emilio G. Cota03719e42016-06-08 14:55:21 -0400280 seqlock_write_end(&timers_state.vm_clock_seqlock);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200281}
282
283/* Correlation between real and virtual time is always going to be
284 fairly approximate, so ignore small variation.
285 When the guest is idle real and virtual time will be aligned in
286 the IO wait loop. */
Rutuja Shah73bcb242016-03-21 21:32:30 +0530287#define ICOUNT_WOBBLE (NANOSECONDS_PER_SECOND / 10)
Paolo Bonzini946fb272011-09-12 13:57:37 +0200288
289static void icount_adjust(void)
290{
291 int64_t cur_time;
292 int64_t cur_icount;
293 int64_t delta;
Paolo Bonzinia3270e12013-10-07 17:18:15 +0200294
295 /* Protected by TimersState mutex. */
Paolo Bonzini946fb272011-09-12 13:57:37 +0200296 static int64_t last_delta;
Paolo Bonzini468cc7c2013-10-07 17:21:51 +0200297
Paolo Bonzini946fb272011-09-12 13:57:37 +0200298 /* If the VM is not running, then do nothing. */
299 if (!runstate_is_running()) {
300 return;
301 }
Paolo Bonzini468cc7c2013-10-07 17:21:51 +0200302
Emilio G. Cota03719e42016-06-08 14:55:21 -0400303 seqlock_write_begin(&timers_state.vm_clock_seqlock);
Paolo Bonzini17a15f12013-10-03 15:17:25 +0200304 cur_time = cpu_get_clock_locked();
305 cur_icount = cpu_get_icount_locked();
Paolo Bonzini468cc7c2013-10-07 17:21:51 +0200306
Paolo Bonzini946fb272011-09-12 13:57:37 +0200307 delta = cur_icount - cur_time;
308 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
309 if (delta > 0
310 && last_delta + ICOUNT_WOBBLE < delta * 2
311 && icount_time_shift > 0) {
312 /* The guest is getting too far ahead. Slow time down. */
313 icount_time_shift--;
314 }
315 if (delta < 0
316 && last_delta - ICOUNT_WOBBLE > delta * 2
317 && icount_time_shift < MAX_ICOUNT_SHIFT) {
318 /* The guest is getting too far behind. Speed time up. */
319 icount_time_shift++;
320 }
321 last_delta = delta;
KONRAD Fredericc96778b2014-08-01 01:37:09 +0200322 timers_state.qemu_icount_bias = cur_icount
323 - (timers_state.qemu_icount << icount_time_shift);
Emilio G. Cota03719e42016-06-08 14:55:21 -0400324 seqlock_write_end(&timers_state.vm_clock_seqlock);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200325}
326
327static void icount_adjust_rt(void *opaque)
328{
Alex Bligh40daca52013-08-21 16:03:02 +0100329 timer_mod(icount_rt_timer,
Pavel Dovgalyuk1979b902015-01-12 15:00:43 +0300330 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT) + 1000);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200331 icount_adjust();
332}
333
334static void icount_adjust_vm(void *opaque)
335{
Alex Bligh40daca52013-08-21 16:03:02 +0100336 timer_mod(icount_vm_timer,
337 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
Rutuja Shah73bcb242016-03-21 21:32:30 +0530338 NANOSECONDS_PER_SECOND / 10);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200339 icount_adjust();
340}
341
342static int64_t qemu_icount_round(int64_t count)
343{
344 return (count + (1 << icount_time_shift) - 1) >> icount_time_shift;
345}
346
Pavel Dovgalyukefab87c2015-09-17 19:24:39 +0300347static void icount_warp_rt(void)
Paolo Bonzini946fb272011-09-12 13:57:37 +0200348{
Alex Bennéeccffff42016-04-04 15:35:48 +0100349 unsigned seq;
350 int64_t warp_start;
351
Paolo Bonzini17a15f12013-10-03 15:17:25 +0200352 /* The icount_warp_timer is rescheduled soon after vm_clock_warp_start
353 * changes from -1 to another value, so the race here is okay.
354 */
Alex Bennéeccffff42016-04-04 15:35:48 +0100355 do {
356 seq = seqlock_read_begin(&timers_state.vm_clock_seqlock);
357 warp_start = vm_clock_warp_start;
358 } while (seqlock_read_retry(&timers_state.vm_clock_seqlock, seq));
359
360 if (warp_start == -1) {
Paolo Bonzini946fb272011-09-12 13:57:37 +0200361 return;
362 }
363
Emilio G. Cota03719e42016-06-08 14:55:21 -0400364 seqlock_write_begin(&timers_state.vm_clock_seqlock);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200365 if (runstate_is_running()) {
Pavel Dovgalyuk8eda2062015-09-17 19:24:28 +0300366 int64_t clock = REPLAY_CLOCK(REPLAY_CLOCK_VIRTUAL_RT,
367 cpu_get_clock_locked());
Paolo Bonzini8ed961d2013-10-07 17:26:07 +0200368 int64_t warp_delta;
369
370 warp_delta = clock - vm_clock_warp_start;
371 if (use_icount == 2) {
Paolo Bonzini946fb272011-09-12 13:57:37 +0200372 /*
Alex Bligh40daca52013-08-21 16:03:02 +0100373 * In adaptive mode, do not let QEMU_CLOCK_VIRTUAL run too
Paolo Bonzini946fb272011-09-12 13:57:37 +0200374 * far ahead of real time.
375 */
Paolo Bonzini17a15f12013-10-03 15:17:25 +0200376 int64_t cur_icount = cpu_get_icount_locked();
Pavel Dovgalyukbf2a7dd2014-11-26 13:40:55 +0300377 int64_t delta = clock - cur_icount;
Paolo Bonzini8ed961d2013-10-07 17:26:07 +0200378 warp_delta = MIN(warp_delta, delta);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200379 }
KONRAD Fredericc96778b2014-08-01 01:37:09 +0200380 timers_state.qemu_icount_bias += warp_delta;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200381 }
382 vm_clock_warp_start = -1;
Emilio G. Cota03719e42016-06-08 14:55:21 -0400383 seqlock_write_end(&timers_state.vm_clock_seqlock);
Paolo Bonzini8ed961d2013-10-07 17:26:07 +0200384
385 if (qemu_clock_expired(QEMU_CLOCK_VIRTUAL)) {
386 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
387 }
Paolo Bonzini946fb272011-09-12 13:57:37 +0200388}
389
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300390static void icount_timer_cb(void *opaque)
Pavel Dovgalyukefab87c2015-09-17 19:24:39 +0300391{
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300392 /* No need for a checkpoint because the timer already synchronizes
393 * with CHECKPOINT_CLOCK_VIRTUAL_RT.
394 */
395 icount_warp_rt();
Pavel Dovgalyukefab87c2015-09-17 19:24:39 +0300396}
397
Paolo Bonzini8156be52012-03-28 15:42:04 +0200398void qtest_clock_warp(int64_t dest)
399{
Alex Bligh40daca52013-08-21 16:03:02 +0100400 int64_t clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
Fam Zhengefef88b2015-01-19 17:51:43 +0800401 AioContext *aio_context;
Paolo Bonzini8156be52012-03-28 15:42:04 +0200402 assert(qtest_enabled());
Fam Zhengefef88b2015-01-19 17:51:43 +0800403 aio_context = qemu_get_aio_context();
Paolo Bonzini8156be52012-03-28 15:42:04 +0200404 while (clock < dest) {
Alex Bligh40daca52013-08-21 16:03:02 +0100405 int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
Sergey Fedorovc9299e22014-06-10 13:10:28 +0400406 int64_t warp = qemu_soonest_timeout(dest - clock, deadline);
Fam Zhengefef88b2015-01-19 17:51:43 +0800407
Emilio G. Cota03719e42016-06-08 14:55:21 -0400408 seqlock_write_begin(&timers_state.vm_clock_seqlock);
KONRAD Fredericc96778b2014-08-01 01:37:09 +0200409 timers_state.qemu_icount_bias += warp;
Emilio G. Cota03719e42016-06-08 14:55:21 -0400410 seqlock_write_end(&timers_state.vm_clock_seqlock);
Paolo Bonzini17a15f12013-10-03 15:17:25 +0200411
Alex Bligh40daca52013-08-21 16:03:02 +0100412 qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
Fam Zhengefef88b2015-01-19 17:51:43 +0800413 timerlist_run_timers(aio_context->tlg.tl[QEMU_CLOCK_VIRTUAL]);
Alex Bligh40daca52013-08-21 16:03:02 +0100414 clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
Paolo Bonzini8156be52012-03-28 15:42:04 +0200415 }
Alex Bligh40daca52013-08-21 16:03:02 +0100416 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
Paolo Bonzini8156be52012-03-28 15:42:04 +0200417}
418
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300419void qemu_start_warp_timer(void)
Paolo Bonzini946fb272011-09-12 13:57:37 +0200420{
Paolo Bonzinice78d182013-10-07 17:30:02 +0200421 int64_t clock;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200422 int64_t deadline;
423
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300424 if (!use_icount) {
Paolo Bonzini946fb272011-09-12 13:57:37 +0200425 return;
426 }
427
Pavel Dovgalyuk8bd7f712015-09-17 19:24:44 +0300428 /* Nothing to do if the VM is stopped: QEMU_CLOCK_VIRTUAL timers
429 * do not fire, so computing the deadline does not make sense.
430 */
431 if (!runstate_is_running()) {
432 return;
433 }
434
435 /* warp clock deterministically in record/replay mode */
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300436 if (!replay_checkpoint(CHECKPOINT_CLOCK_WARP_START)) {
Pavel Dovgalyuk8bd7f712015-09-17 19:24:44 +0300437 return;
438 }
439
Paolo Bonzinice78d182013-10-07 17:30:02 +0200440 if (!all_cpu_threads_idle()) {
Paolo Bonzini946fb272011-09-12 13:57:37 +0200441 return;
442 }
443
Paolo Bonzini8156be52012-03-28 15:42:04 +0200444 if (qtest_enabled()) {
445 /* When testing, qtest commands advance icount. */
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300446 return;
Paolo Bonzini8156be52012-03-28 15:42:04 +0200447 }
448
Alex Blighac70aaf2013-08-21 16:02:57 +0100449 /* We want to use the earliest deadline from ALL vm_clocks */
Pavel Dovgalyukbf2a7dd2014-11-26 13:40:55 +0300450 clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT);
Alex Bligh40daca52013-08-21 16:03:02 +0100451 deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
Paolo Bonzinice78d182013-10-07 17:30:02 +0200452 if (deadline < 0) {
Victor CLEMENTd7a0f712015-05-29 17:14:06 +0200453 static bool notified;
454 if (!icount_sleep && !notified) {
455 error_report("WARNING: icount sleep disabled and no active timers");
456 notified = true;
457 }
Paolo Bonzinice78d182013-10-07 17:30:02 +0200458 return;
Alex Blighac70aaf2013-08-21 16:02:57 +0100459 }
460
Paolo Bonzini946fb272011-09-12 13:57:37 +0200461 if (deadline > 0) {
462 /*
Alex Bligh40daca52013-08-21 16:03:02 +0100463 * Ensure QEMU_CLOCK_VIRTUAL proceeds even when the virtual CPU goes to
Paolo Bonzini946fb272011-09-12 13:57:37 +0200464 * sleep. Otherwise, the CPU might be waiting for a future timer
465 * interrupt to wake it up, but the interrupt never comes because
466 * the vCPU isn't running any insns and thus doesn't advance the
Alex Bligh40daca52013-08-21 16:03:02 +0100467 * QEMU_CLOCK_VIRTUAL.
Paolo Bonzini946fb272011-09-12 13:57:37 +0200468 */
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200469 if (!icount_sleep) {
470 /*
471 * We never let VCPUs sleep in no sleep icount mode.
472 * If there is a pending QEMU_CLOCK_VIRTUAL timer we just advance
473 * to the next QEMU_CLOCK_VIRTUAL event and notify it.
474 * It is useful when we want a deterministic execution time,
475 * isolated from host latencies.
476 */
Emilio G. Cota03719e42016-06-08 14:55:21 -0400477 seqlock_write_begin(&timers_state.vm_clock_seqlock);
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200478 timers_state.qemu_icount_bias += deadline;
Emilio G. Cota03719e42016-06-08 14:55:21 -0400479 seqlock_write_end(&timers_state.vm_clock_seqlock);
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200480 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
481 } else {
482 /*
483 * We do stop VCPUs and only advance QEMU_CLOCK_VIRTUAL after some
484 * "real" time, (related to the time left until the next event) has
485 * passed. The QEMU_CLOCK_VIRTUAL_RT clock will do this.
486 * This avoids that the warps are visible externally; for example,
487 * you will not be sending network packets continuously instead of
488 * every 100ms.
489 */
Emilio G. Cota03719e42016-06-08 14:55:21 -0400490 seqlock_write_begin(&timers_state.vm_clock_seqlock);
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200491 if (vm_clock_warp_start == -1 || vm_clock_warp_start > clock) {
492 vm_clock_warp_start = clock;
493 }
Emilio G. Cota03719e42016-06-08 14:55:21 -0400494 seqlock_write_end(&timers_state.vm_clock_seqlock);
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200495 timer_mod_anticipate(icount_warp_timer, clock + deadline);
Paolo Bonzinice78d182013-10-07 17:30:02 +0200496 }
Alex Blighac70aaf2013-08-21 16:02:57 +0100497 } else if (deadline == 0) {
Alex Bligh40daca52013-08-21 16:03:02 +0100498 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200499 }
500}
501
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300502static void qemu_account_warp_timer(void)
503{
504 if (!use_icount || !icount_sleep) {
505 return;
506 }
507
508 /* Nothing to do if the VM is stopped: QEMU_CLOCK_VIRTUAL timers
509 * do not fire, so computing the deadline does not make sense.
510 */
511 if (!runstate_is_running()) {
512 return;
513 }
514
515 /* warp clock deterministically in record/replay mode */
516 if (!replay_checkpoint(CHECKPOINT_CLOCK_WARP_ACCOUNT)) {
517 return;
518 }
519
520 timer_del(icount_warp_timer);
521 icount_warp_rt();
522}
523
KONRAD Fredericd09eae32014-08-01 01:37:10 +0200524static bool icount_state_needed(void *opaque)
525{
526 return use_icount;
527}
528
529/*
530 * This is a subsection for icount migration.
531 */
532static const VMStateDescription icount_vmstate_timers = {
533 .name = "timer/icount",
534 .version_id = 1,
535 .minimum_version_id = 1,
Juan Quintela5cd8cad2014-09-23 14:09:54 +0200536 .needed = icount_state_needed,
KONRAD Fredericd09eae32014-08-01 01:37:10 +0200537 .fields = (VMStateField[]) {
538 VMSTATE_INT64(qemu_icount_bias, TimersState),
539 VMSTATE_INT64(qemu_icount, TimersState),
540 VMSTATE_END_OF_LIST()
541 }
542};
543
Paolo Bonzini946fb272011-09-12 13:57:37 +0200544static const VMStateDescription vmstate_timers = {
545 .name = "timer",
546 .version_id = 2,
547 .minimum_version_id = 1,
Juan Quintela35d08452014-04-16 16:01:33 +0200548 .fields = (VMStateField[]) {
Paolo Bonzini946fb272011-09-12 13:57:37 +0200549 VMSTATE_INT64(cpu_ticks_offset, TimersState),
550 VMSTATE_INT64(dummy, TimersState),
551 VMSTATE_INT64_V(cpu_clock_offset, TimersState, 2),
552 VMSTATE_END_OF_LIST()
KONRAD Fredericd09eae32014-08-01 01:37:10 +0200553 },
Juan Quintela5cd8cad2014-09-23 14:09:54 +0200554 .subsections = (const VMStateDescription*[]) {
555 &icount_vmstate_timers,
556 NULL
Paolo Bonzini946fb272011-09-12 13:57:37 +0200557 }
558};
559
Paolo Bonzini14e6fe12016-10-31 10:36:08 +0100560static void cpu_throttle_thread(CPUState *cpu, run_on_cpu_data opaque)
Jason J. Herne2adcc852015-09-08 13:12:33 -0400561{
Jason J. Herne2adcc852015-09-08 13:12:33 -0400562 double pct;
563 double throttle_ratio;
564 long sleeptime_ns;
565
566 if (!cpu_throttle_get_percentage()) {
567 return;
568 }
569
570 pct = (double)cpu_throttle_get_percentage()/100;
571 throttle_ratio = pct / (1 - pct);
572 sleeptime_ns = (long)(throttle_ratio * CPU_THROTTLE_TIMESLICE_NS);
573
574 qemu_mutex_unlock_iothread();
575 atomic_set(&cpu->throttle_thread_scheduled, 0);
576 g_usleep(sleeptime_ns / 1000); /* Convert ns to us for usleep call */
577 qemu_mutex_lock_iothread();
578}
579
580static void cpu_throttle_timer_tick(void *opaque)
581{
582 CPUState *cpu;
583 double pct;
584
585 /* Stop the timer if needed */
586 if (!cpu_throttle_get_percentage()) {
587 return;
588 }
589 CPU_FOREACH(cpu) {
590 if (!atomic_xchg(&cpu->throttle_thread_scheduled, 1)) {
Paolo Bonzini14e6fe12016-10-31 10:36:08 +0100591 async_run_on_cpu(cpu, cpu_throttle_thread,
592 RUN_ON_CPU_NULL);
Jason J. Herne2adcc852015-09-08 13:12:33 -0400593 }
594 }
595
596 pct = (double)cpu_throttle_get_percentage()/100;
597 timer_mod(throttle_timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT) +
598 CPU_THROTTLE_TIMESLICE_NS / (1-pct));
599}
600
601void cpu_throttle_set(int new_throttle_pct)
602{
603 /* Ensure throttle percentage is within valid range */
604 new_throttle_pct = MIN(new_throttle_pct, CPU_THROTTLE_PCT_MAX);
605 new_throttle_pct = MAX(new_throttle_pct, CPU_THROTTLE_PCT_MIN);
606
607 atomic_set(&throttle_percentage, new_throttle_pct);
608
609 timer_mod(throttle_timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT) +
610 CPU_THROTTLE_TIMESLICE_NS);
611}
612
613void cpu_throttle_stop(void)
614{
615 atomic_set(&throttle_percentage, 0);
616}
617
618bool cpu_throttle_active(void)
619{
620 return (cpu_throttle_get_percentage() != 0);
621}
622
623int cpu_throttle_get_percentage(void)
624{
625 return atomic_read(&throttle_percentage);
626}
627
Pavel Dovgalyuk4603ea02014-09-01 09:34:49 +0400628void cpu_ticks_init(void)
629{
Emilio G. Cotaccdb3c12016-06-08 14:55:20 -0400630 seqlock_init(&timers_state.vm_clock_seqlock);
Pavel Dovgalyuk4603ea02014-09-01 09:34:49 +0400631 vmstate_register(NULL, 0, &vmstate_timers, &timers_state);
Jason J. Herne2adcc852015-09-08 13:12:33 -0400632 throttle_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL_RT,
633 cpu_throttle_timer_tick, NULL);
Pavel Dovgalyuk4603ea02014-09-01 09:34:49 +0400634}
635
Sebastian Tanase1ad95802014-07-25 11:56:28 +0200636void configure_icount(QemuOpts *opts, Error **errp)
Paolo Bonzini946fb272011-09-12 13:57:37 +0200637{
Sebastian Tanase1ad95802014-07-25 11:56:28 +0200638 const char *option;
Sebastian Tanasea8bfac32014-07-25 11:56:29 +0200639 char *rem_str = NULL;
Sebastian Tanase1ad95802014-07-25 11:56:28 +0200640
Sebastian Tanase1ad95802014-07-25 11:56:28 +0200641 option = qemu_opt_get(opts, "shift");
Paolo Bonzini946fb272011-09-12 13:57:37 +0200642 if (!option) {
Sebastian Tanasea8bfac32014-07-25 11:56:29 +0200643 if (qemu_opt_get(opts, "align") != NULL) {
644 error_setg(errp, "Please specify shift option when using align");
645 }
Paolo Bonzini946fb272011-09-12 13:57:37 +0200646 return;
647 }
Victor CLEMENTf1f4b572015-05-29 17:14:05 +0200648
649 icount_sleep = qemu_opt_get_bool(opts, "sleep", true);
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200650 if (icount_sleep) {
651 icount_warp_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL_RT,
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300652 icount_timer_cb, NULL);
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200653 }
Victor CLEMENTf1f4b572015-05-29 17:14:05 +0200654
Sebastian Tanasea8bfac32014-07-25 11:56:29 +0200655 icount_align_option = qemu_opt_get_bool(opts, "align", false);
Victor CLEMENTf1f4b572015-05-29 17:14:05 +0200656
657 if (icount_align_option && !icount_sleep) {
Pranith Kumar778d9f92016-02-26 10:16:51 -0500658 error_setg(errp, "align=on and sleep=off are incompatible");
Victor CLEMENTf1f4b572015-05-29 17:14:05 +0200659 }
Paolo Bonzini946fb272011-09-12 13:57:37 +0200660 if (strcmp(option, "auto") != 0) {
Sebastian Tanasea8bfac32014-07-25 11:56:29 +0200661 errno = 0;
662 icount_time_shift = strtol(option, &rem_str, 0);
663 if (errno != 0 || *rem_str != '\0' || !strlen(option)) {
664 error_setg(errp, "icount: Invalid shift value");
665 }
Paolo Bonzini946fb272011-09-12 13:57:37 +0200666 use_icount = 1;
667 return;
Sebastian Tanasea8bfac32014-07-25 11:56:29 +0200668 } else if (icount_align_option) {
669 error_setg(errp, "shift=auto and align=on are incompatible");
Victor CLEMENTf1f4b572015-05-29 17:14:05 +0200670 } else if (!icount_sleep) {
Pranith Kumar778d9f92016-02-26 10:16:51 -0500671 error_setg(errp, "shift=auto and sleep=off are incompatible");
Paolo Bonzini946fb272011-09-12 13:57:37 +0200672 }
673
674 use_icount = 2;
675
676 /* 125MIPS seems a reasonable initial guess at the guest speed.
677 It will be corrected fairly quickly anyway. */
678 icount_time_shift = 3;
679
680 /* Have both realtime and virtual time triggers for speed adjustment.
681 The realtime trigger catches emulated time passing too slowly,
682 the virtual time trigger catches emulated time passing too fast.
683 Realtime triggers occur even when idle, so use them less frequently
684 than VM triggers. */
Pavel Dovgalyukbf2a7dd2014-11-26 13:40:55 +0300685 icount_rt_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL_RT,
686 icount_adjust_rt, NULL);
Alex Bligh40daca52013-08-21 16:03:02 +0100687 timer_mod(icount_rt_timer,
Pavel Dovgalyukbf2a7dd2014-11-26 13:40:55 +0300688 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT) + 1000);
Alex Bligh40daca52013-08-21 16:03:02 +0100689 icount_vm_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
690 icount_adjust_vm, NULL);
691 timer_mod(icount_vm_timer,
692 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
Rutuja Shah73bcb242016-03-21 21:32:30 +0530693 NANOSECONDS_PER_SECOND / 10);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200694}
695
696/***********************************************************/
Blue Swirl296af7c2010-03-29 19:23:50 +0000697void hw_error(const char *fmt, ...)
698{
699 va_list ap;
Andreas Färber55e5c282012-12-17 06:18:02 +0100700 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +0000701
702 va_start(ap, fmt);
703 fprintf(stderr, "qemu: hardware error: ");
704 vfprintf(stderr, fmt, ap);
705 fprintf(stderr, "\n");
Andreas Färberbdc44642013-06-24 23:50:24 +0200706 CPU_FOREACH(cpu) {
Andreas Färber55e5c282012-12-17 06:18:02 +0100707 fprintf(stderr, "CPU #%d:\n", cpu->cpu_index);
Andreas Färber878096e2013-05-27 01:33:50 +0200708 cpu_dump_state(cpu, stderr, fprintf, CPU_DUMP_FPU);
Blue Swirl296af7c2010-03-29 19:23:50 +0000709 }
710 va_end(ap);
711 abort();
712}
713
714void cpu_synchronize_all_states(void)
715{
Andreas Färber182735e2013-05-29 22:29:20 +0200716 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +0000717
Andreas Färberbdc44642013-06-24 23:50:24 +0200718 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +0200719 cpu_synchronize_state(cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +0000720 }
721}
722
723void cpu_synchronize_all_post_reset(void)
724{
Andreas Färber182735e2013-05-29 22:29:20 +0200725 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +0000726
Andreas Färberbdc44642013-06-24 23:50:24 +0200727 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +0200728 cpu_synchronize_post_reset(cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +0000729 }
730}
731
732void cpu_synchronize_all_post_init(void)
733{
Andreas Färber182735e2013-05-29 22:29:20 +0200734 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +0000735
Andreas Färberbdc44642013-06-24 23:50:24 +0200736 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +0200737 cpu_synchronize_post_init(cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +0000738 }
739}
740
Kevin Wolf56983462013-07-05 13:49:54 +0200741static int do_vm_stop(RunState state)
Blue Swirl296af7c2010-03-29 19:23:50 +0000742{
Kevin Wolf56983462013-07-05 13:49:54 +0200743 int ret = 0;
744
Luiz Capitulino13548692011-07-29 15:36:43 -0300745 if (runstate_is_running()) {
Blue Swirl296af7c2010-03-29 19:23:50 +0000746 cpu_disable_ticks();
Blue Swirl296af7c2010-03-29 19:23:50 +0000747 pause_all_vcpus();
Luiz Capitulinof5bbfba2011-07-29 15:04:45 -0300748 runstate_set(state);
Luiz Capitulino1dfb4dd2011-07-29 14:26:33 -0300749 vm_state_notify(0, state);
Wenchao Xiaa4e15de2014-06-18 08:43:36 +0200750 qapi_event_send_stop(&error_abort);
Blue Swirl296af7c2010-03-29 19:23:50 +0000751 }
Kevin Wolf56983462013-07-05 13:49:54 +0200752
Kevin Wolf594a45c2013-07-18 14:52:19 +0200753 bdrv_drain_all();
Pavel Dovgalyuk6d0ceb82016-09-26 11:08:16 +0300754 replay_disable_events();
John Snow22af08e2016-09-22 21:45:51 -0400755 ret = bdrv_flush_all();
Kevin Wolf594a45c2013-07-18 14:52:19 +0200756
Kevin Wolf56983462013-07-05 13:49:54 +0200757 return ret;
Blue Swirl296af7c2010-03-29 19:23:50 +0000758}
759
Andreas Färbera1fcaa72012-05-02 23:42:26 +0200760static bool cpu_can_run(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +0000761{
Andreas Färber4fdeee72012-05-02 23:10:09 +0200762 if (cpu->stop) {
Andreas Färbera1fcaa72012-05-02 23:42:26 +0200763 return false;
Jan Kiszka0ab07c62011-02-07 12:19:14 +0100764 }
Tiejun Chen321bc0b2013-08-02 09:43:09 +0800765 if (cpu_is_stopped(cpu)) {
Andreas Färbera1fcaa72012-05-02 23:42:26 +0200766 return false;
Jan Kiszka0ab07c62011-02-07 12:19:14 +0100767 }
Andreas Färbera1fcaa72012-05-02 23:42:26 +0200768 return true;
Blue Swirl296af7c2010-03-29 19:23:50 +0000769}
770
Andreas Färber91325042013-05-27 02:07:49 +0200771static void cpu_handle_guest_debug(CPUState *cpu)
Jan Kiszka3c638d02010-06-25 16:56:56 +0200772{
Andreas Färber64f6b342013-05-27 02:06:09 +0200773 gdb_set_stop_cpu(cpu);
Jan Kiszka8cf71712011-02-07 12:19:16 +0100774 qemu_system_debug_request();
Andreas Färberf324e762012-05-02 23:26:21 +0200775 cpu->stopped = true;
Jan Kiszka3c638d02010-06-25 16:56:56 +0200776}
777
Jan Kiszka6d9cb732011-02-01 22:15:58 +0100778#ifdef CONFIG_LINUX
779static void sigbus_reraise(void)
780{
781 sigset_t set;
782 struct sigaction action;
783
784 memset(&action, 0, sizeof(action));
785 action.sa_handler = SIG_DFL;
786 if (!sigaction(SIGBUS, &action, NULL)) {
787 raise(SIGBUS);
788 sigemptyset(&set);
789 sigaddset(&set, SIGBUS);
Peter Maydella2d17612016-05-16 18:33:59 +0100790 pthread_sigmask(SIG_UNBLOCK, &set, NULL);
Jan Kiszka6d9cb732011-02-01 22:15:58 +0100791 }
792 perror("Failed to re-raise SIGBUS!\n");
793 abort();
794}
795
796static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo,
797 void *ctx)
798{
799 if (kvm_on_sigbus(siginfo->ssi_code,
800 (void *)(intptr_t)siginfo->ssi_addr)) {
801 sigbus_reraise();
802 }
803}
804
805static void qemu_init_sigbus(void)
806{
807 struct sigaction action;
808
809 memset(&action, 0, sizeof(action));
810 action.sa_flags = SA_SIGINFO;
811 action.sa_sigaction = (void (*)(int, siginfo_t*, void*))sigbus_handler;
812 sigaction(SIGBUS, &action, NULL);
813
814 prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, 0, 0);
815}
816
Andreas Färber290adf32013-01-17 09:30:27 +0100817static void qemu_kvm_eat_signals(CPUState *cpu)
Jan Kiszka1ab3c6c2011-03-15 12:26:12 +0100818{
819 struct timespec ts = { 0, 0 };
820 siginfo_t siginfo;
821 sigset_t waitset;
822 sigset_t chkset;
823 int r;
824
825 sigemptyset(&waitset);
826 sigaddset(&waitset, SIG_IPI);
827 sigaddset(&waitset, SIGBUS);
828
829 do {
830 r = sigtimedwait(&waitset, &siginfo, &ts);
831 if (r == -1 && !(errno == EAGAIN || errno == EINTR)) {
832 perror("sigtimedwait");
833 exit(1);
834 }
835
836 switch (r) {
837 case SIGBUS:
Andreas Färber290adf32013-01-17 09:30:27 +0100838 if (kvm_on_sigbus_vcpu(cpu, siginfo.si_code, siginfo.si_addr)) {
Jan Kiszka1ab3c6c2011-03-15 12:26:12 +0100839 sigbus_reraise();
840 }
841 break;
842 default:
843 break;
844 }
845
846 r = sigpending(&chkset);
847 if (r == -1) {
848 perror("sigpending");
849 exit(1);
850 }
851 } while (sigismember(&chkset, SIG_IPI) || sigismember(&chkset, SIGBUS));
Jan Kiszka1ab3c6c2011-03-15 12:26:12 +0100852}
853
Jan Kiszka6d9cb732011-02-01 22:15:58 +0100854#else /* !CONFIG_LINUX */
855
856static void qemu_init_sigbus(void)
857{
858}
Jan Kiszka1ab3c6c2011-03-15 12:26:12 +0100859
Andreas Färber290adf32013-01-17 09:30:27 +0100860static void qemu_kvm_eat_signals(CPUState *cpu)
Jan Kiszka1ab3c6c2011-03-15 12:26:12 +0100861{
862}
Jan Kiszka6d9cb732011-02-01 22:15:58 +0100863#endif /* !CONFIG_LINUX */
864
Blue Swirl296af7c2010-03-29 19:23:50 +0000865#ifndef _WIN32
Jan Kiszka55f8d6a2011-02-01 22:15:52 +0100866static void dummy_signal(int sig)
Blue Swirl296af7c2010-03-29 19:23:50 +0000867{
868}
869
Andreas Färber13618e02013-05-26 23:41:00 +0200870static void qemu_kvm_init_cpu_signals(CPUState *cpu)
Paolo Bonzini714bd042011-03-12 17:44:06 +0100871{
872 int r;
873 sigset_t set;
874 struct sigaction sigact;
875
876 memset(&sigact, 0, sizeof(sigact));
877 sigact.sa_handler = dummy_signal;
878 sigaction(SIG_IPI, &sigact, NULL);
879
Paolo Bonzini714bd042011-03-12 17:44:06 +0100880 pthread_sigmask(SIG_BLOCK, NULL, &set);
881 sigdelset(&set, SIG_IPI);
882 sigdelset(&set, SIGBUS);
Andreas Färber491d6e82013-05-26 23:38:10 +0200883 r = kvm_set_signal_mask(cpu, &set);
Paolo Bonzini714bd042011-03-12 17:44:06 +0100884 if (r) {
885 fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));
886 exit(1);
887 }
Paolo Bonzini714bd042011-03-12 17:44:06 +0100888}
889
Jan Kiszka55f8d6a2011-02-01 22:15:52 +0100890#else /* _WIN32 */
Andreas Färber13618e02013-05-26 23:41:00 +0200891static void qemu_kvm_init_cpu_signals(CPUState *cpu)
Paolo Bonzini714bd042011-03-12 17:44:06 +0100892{
893 abort();
894}
Jan Kiszka55f8d6a2011-02-01 22:15:52 +0100895#endif /* _WIN32 */
Blue Swirl296af7c2010-03-29 19:23:50 +0000896
Stefan Weilb2532d82012-09-27 07:41:42 +0200897static QemuMutex qemu_global_mutex;
Paolo Bonzini46daff12011-06-09 13:10:24 +0200898static QemuCond qemu_io_proceeded_cond;
Paolo Bonzini6b498092015-02-27 19:58:23 +0100899static unsigned iothread_requesting_mutex;
Blue Swirl296af7c2010-03-29 19:23:50 +0000900
901static QemuThread io_thread;
902
Blue Swirl296af7c2010-03-29 19:23:50 +0000903/* cpu creation */
904static QemuCond qemu_cpu_cond;
905/* system init */
Blue Swirl296af7c2010-03-29 19:23:50 +0000906static QemuCond qemu_pause_cond;
907
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200908void qemu_init_cpu_loop(void)
Blue Swirl296af7c2010-03-29 19:23:50 +0000909{
Jan Kiszka6d9cb732011-02-01 22:15:58 +0100910 qemu_init_sigbus();
Anthony Liguoried945922011-02-08 18:18:18 +0100911 qemu_cond_init(&qemu_cpu_cond);
Anthony Liguoried945922011-02-08 18:18:18 +0100912 qemu_cond_init(&qemu_pause_cond);
Paolo Bonzini46daff12011-06-09 13:10:24 +0200913 qemu_cond_init(&qemu_io_proceeded_cond);
Blue Swirl296af7c2010-03-29 19:23:50 +0000914 qemu_mutex_init(&qemu_global_mutex);
Blue Swirl296af7c2010-03-29 19:23:50 +0000915
Jan Kiszkab7680cb2011-03-12 17:43:51 +0100916 qemu_thread_get_self(&io_thread);
Blue Swirl296af7c2010-03-29 19:23:50 +0000917}
918
Paolo Bonzini14e6fe12016-10-31 10:36:08 +0100919void run_on_cpu(CPUState *cpu, run_on_cpu_func func, run_on_cpu_data data)
Marcelo Tosattie82bcec2010-05-04 09:45:22 -0300920{
Sergey Fedorovd148d902016-08-29 09:51:00 +0200921 do_run_on_cpu(cpu, func, data, &qemu_global_mutex);
Chegu Vinod3c022702013-06-24 03:49:41 -0600922}
923
Gu Zheng4c055ab2016-05-12 09:18:13 +0530924static void qemu_kvm_destroy_vcpu(CPUState *cpu)
925{
926 if (kvm_destroy_vcpu(cpu) < 0) {
927 error_report("kvm_destroy_vcpu failed");
928 exit(EXIT_FAILURE);
929 }
930}
931
932static void qemu_tcg_destroy_vcpu(CPUState *cpu)
933{
934}
935
Andreas Färber509a0d72012-05-03 02:18:09 +0200936static void qemu_wait_io_event_common(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +0000937{
Andreas Färber4fdeee72012-05-02 23:10:09 +0200938 if (cpu->stop) {
939 cpu->stop = false;
Andreas Färberf324e762012-05-02 23:26:21 +0200940 cpu->stopped = true;
Dr. David Alan Gilbert96bce682016-01-25 10:08:18 +0000941 qemu_cond_broadcast(&qemu_pause_cond);
Blue Swirl296af7c2010-03-29 19:23:50 +0000942 }
Sergey Fedorova5403c62016-08-02 18:27:36 +0100943 process_queued_cpu_work(cpu);
Andreas Färber216fc9a2012-05-02 17:49:49 +0200944 cpu->thread_kicked = false;
Blue Swirl296af7c2010-03-29 19:23:50 +0000945}
946
KONRAD Fredericd5f8d612015-08-10 17:27:06 +0200947static void qemu_tcg_wait_io_event(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +0000948{
Jan Kiszka16400322011-02-09 16:29:37 +0100949 while (all_cpu_threads_idle()) {
KONRAD Fredericd5f8d612015-08-10 17:27:06 +0200950 qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
Jan Kiszka16400322011-02-09 16:29:37 +0100951 }
Blue Swirl296af7c2010-03-29 19:23:50 +0000952
Paolo Bonzini46daff12011-06-09 13:10:24 +0200953 while (iothread_requesting_mutex) {
954 qemu_cond_wait(&qemu_io_proceeded_cond, &qemu_global_mutex);
955 }
Jan Kiszka6cabe1f2010-06-25 16:56:53 +0200956
Andreas Färberbdc44642013-06-24 23:50:24 +0200957 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +0200958 qemu_wait_io_event_common(cpu);
Jan Kiszka6cabe1f2010-06-25 16:56:53 +0200959 }
Blue Swirl296af7c2010-03-29 19:23:50 +0000960}
961
Andreas Färberfd529e82013-05-26 23:24:55 +0200962static void qemu_kvm_wait_io_event(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +0000963{
Andreas Färbera98ae1d2013-05-26 23:21:08 +0200964 while (cpu_thread_is_idle(cpu)) {
Andreas Färberf5c121b2012-05-03 01:22:49 +0200965 qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
Jan Kiszka16400322011-02-09 16:29:37 +0100966 }
Blue Swirl296af7c2010-03-29 19:23:50 +0000967
Andreas Färber290adf32013-01-17 09:30:27 +0100968 qemu_kvm_eat_signals(cpu);
Andreas Färber509a0d72012-05-03 02:18:09 +0200969 qemu_wait_io_event_common(cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +0000970}
971
Jan Kiszka7e97cd82011-02-07 12:19:12 +0100972static void *qemu_kvm_cpu_thread_fn(void *arg)
Blue Swirl296af7c2010-03-29 19:23:50 +0000973{
Andreas Färber48a106b2013-05-27 02:20:39 +0200974 CPUState *cpu = arg;
Jan Kiszka84b49152011-02-01 22:15:50 +0100975 int r;
Blue Swirl296af7c2010-03-29 19:23:50 +0000976
Paolo Bonziniab28bd22015-07-09 08:55:38 +0200977 rcu_register_thread();
978
Paolo Bonzini2e7f7a32015-06-18 18:47:18 +0200979 qemu_mutex_lock_iothread();
Andreas Färber814e6122012-05-02 17:00:37 +0200980 qemu_thread_get_self(cpu->thread);
Andreas Färber9f09e182012-05-03 06:59:07 +0200981 cpu->thread_id = qemu_get_thread_id();
Pavel Dovgalyuk626cf8f2014-12-08 10:53:17 +0300982 cpu->can_do_io = 1;
Andreas Färber4917cf42013-05-27 05:17:50 +0200983 current_cpu = cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +0000984
Andreas Färber504134d2012-12-17 06:38:45 +0100985 r = kvm_init_vcpu(cpu);
Jan Kiszka84b49152011-02-01 22:15:50 +0100986 if (r < 0) {
987 fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r));
988 exit(1);
989 }
Blue Swirl296af7c2010-03-29 19:23:50 +0000990
Andreas Färber13618e02013-05-26 23:41:00 +0200991 qemu_kvm_init_cpu_signals(cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +0000992
993 /* signal CPU creation */
Andreas Färber61a46212012-05-02 22:49:36 +0200994 cpu->created = true;
Blue Swirl296af7c2010-03-29 19:23:50 +0000995 qemu_cond_signal(&qemu_cpu_cond);
996
Gu Zheng4c055ab2016-05-12 09:18:13 +0530997 do {
Andreas Färbera1fcaa72012-05-02 23:42:26 +0200998 if (cpu_can_run(cpu)) {
Andreas Färber1458c362013-05-26 23:46:55 +0200999 r = kvm_cpu_exec(cpu);
Jan Kiszka83f338f2011-02-07 12:19:17 +01001000 if (r == EXCP_DEBUG) {
Andreas Färber91325042013-05-27 02:07:49 +02001001 cpu_handle_guest_debug(cpu);
Jan Kiszka83f338f2011-02-07 12:19:17 +01001002 }
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001003 }
Andreas Färberfd529e82013-05-26 23:24:55 +02001004 qemu_kvm_wait_io_event(cpu);
Gu Zheng4c055ab2016-05-12 09:18:13 +05301005 } while (!cpu->unplug || cpu_can_run(cpu));
Blue Swirl296af7c2010-03-29 19:23:50 +00001006
Gu Zheng4c055ab2016-05-12 09:18:13 +05301007 qemu_kvm_destroy_vcpu(cpu);
Bharata B Rao2c579042016-05-12 09:18:14 +05301008 cpu->created = false;
1009 qemu_cond_signal(&qemu_cpu_cond);
Gu Zheng4c055ab2016-05-12 09:18:13 +05301010 qemu_mutex_unlock_iothread();
Blue Swirl296af7c2010-03-29 19:23:50 +00001011 return NULL;
1012}
1013
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001014static void *qemu_dummy_cpu_thread_fn(void *arg)
1015{
1016#ifdef _WIN32
1017 fprintf(stderr, "qtest is not supported under Windows\n");
1018 exit(1);
1019#else
Andreas Färber10a90212013-05-27 02:24:35 +02001020 CPUState *cpu = arg;
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001021 sigset_t waitset;
1022 int r;
1023
Paolo Bonziniab28bd22015-07-09 08:55:38 +02001024 rcu_register_thread();
1025
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001026 qemu_mutex_lock_iothread();
Andreas Färber814e6122012-05-02 17:00:37 +02001027 qemu_thread_get_self(cpu->thread);
Andreas Färber9f09e182012-05-03 06:59:07 +02001028 cpu->thread_id = qemu_get_thread_id();
Pavel Dovgalyuk626cf8f2014-12-08 10:53:17 +03001029 cpu->can_do_io = 1;
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001030
1031 sigemptyset(&waitset);
1032 sigaddset(&waitset, SIG_IPI);
1033
1034 /* signal CPU creation */
Andreas Färber61a46212012-05-02 22:49:36 +02001035 cpu->created = true;
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001036 qemu_cond_signal(&qemu_cpu_cond);
1037
Andreas Färber4917cf42013-05-27 05:17:50 +02001038 current_cpu = cpu;
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001039 while (1) {
Andreas Färber4917cf42013-05-27 05:17:50 +02001040 current_cpu = NULL;
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001041 qemu_mutex_unlock_iothread();
1042 do {
1043 int sig;
1044 r = sigwait(&waitset, &sig);
1045 } while (r == -1 && (errno == EAGAIN || errno == EINTR));
1046 if (r == -1) {
1047 perror("sigwait");
1048 exit(1);
1049 }
1050 qemu_mutex_lock_iothread();
Andreas Färber4917cf42013-05-27 05:17:50 +02001051 current_cpu = cpu;
Andreas Färber509a0d72012-05-03 02:18:09 +02001052 qemu_wait_io_event_common(cpu);
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001053 }
1054
1055 return NULL;
1056#endif
1057}
1058
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001059static int64_t tcg_get_icount_limit(void)
1060{
1061 int64_t deadline;
1062
1063 if (replay_mode != REPLAY_MODE_PLAY) {
1064 deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
1065
1066 /* Maintain prior (possibly buggy) behaviour where if no deadline
1067 * was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than
1068 * INT32_MAX nanoseconds ahead, we still use INT32_MAX
1069 * nanoseconds.
1070 */
1071 if ((deadline < 0) || (deadline > INT32_MAX)) {
1072 deadline = INT32_MAX;
1073 }
1074
1075 return qemu_icount_round(deadline);
1076 } else {
1077 return replay_get_instructions();
1078 }
1079}
1080
Alex Bennée12e97002016-10-27 16:10:14 +01001081static void handle_icount_deadline(void)
1082{
1083 if (use_icount) {
1084 int64_t deadline =
1085 qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
1086
1087 if (deadline == 0) {
1088 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
1089 }
1090 }
1091}
1092
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001093static int tcg_cpu_exec(CPUState *cpu)
1094{
1095 int ret;
1096#ifdef CONFIG_PROFILER
1097 int64_t ti;
1098#endif
1099
1100#ifdef CONFIG_PROFILER
1101 ti = profile_getclock();
1102#endif
1103 if (use_icount) {
1104 int64_t count;
1105 int decr;
1106 timers_state.qemu_icount -= (cpu->icount_decr.u16.low
1107 + cpu->icount_extra);
1108 cpu->icount_decr.u16.low = 0;
1109 cpu->icount_extra = 0;
1110 count = tcg_get_icount_limit();
1111 timers_state.qemu_icount += count;
1112 decr = (count > 0xffff) ? 0xffff : count;
1113 count -= decr;
1114 cpu->icount_decr.u16.low = decr;
1115 cpu->icount_extra = count;
1116 }
1117 cpu_exec_start(cpu);
1118 ret = cpu_exec(cpu);
1119 cpu_exec_end(cpu);
1120#ifdef CONFIG_PROFILER
1121 tcg_time += profile_getclock() - ti;
1122#endif
1123 if (use_icount) {
1124 /* Fold pending instructions back into the
1125 instruction counter, and clear the interrupt flag. */
1126 timers_state.qemu_icount -= (cpu->icount_decr.u16.low
1127 + cpu->icount_extra);
1128 cpu->icount_decr.u32 = 0;
1129 cpu->icount_extra = 0;
1130 replay_account_executed_instructions();
1131 }
1132 return ret;
1133}
1134
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001135/* Destroy any remaining vCPUs which have been unplugged and have
1136 * finished running
1137 */
1138static void deal_with_unplugged_cpus(void)
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001139{
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001140 CPUState *cpu;
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001141
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001142 CPU_FOREACH(cpu) {
1143 if (cpu->unplug && !cpu_can_run(cpu)) {
1144 qemu_tcg_destroy_vcpu(cpu);
1145 cpu->created = false;
1146 qemu_cond_signal(&qemu_cpu_cond);
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001147 break;
1148 }
1149 }
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001150}
Jan Kiszkabdb7ca62011-09-26 09:40:39 +02001151
Jan Kiszka7e97cd82011-02-07 12:19:12 +01001152static void *qemu_tcg_cpu_thread_fn(void *arg)
Blue Swirl296af7c2010-03-29 19:23:50 +00001153{
Andreas Färberc3586ba2012-05-03 01:41:24 +02001154 CPUState *cpu = arg;
Blue Swirl296af7c2010-03-29 19:23:50 +00001155
Paolo Bonziniab28bd22015-07-09 08:55:38 +02001156 rcu_register_thread();
1157
Paolo Bonzini2e7f7a32015-06-18 18:47:18 +02001158 qemu_mutex_lock_iothread();
Andreas Färber814e6122012-05-02 17:00:37 +02001159 qemu_thread_get_self(cpu->thread);
Blue Swirl296af7c2010-03-29 19:23:50 +00001160
Andreas Färber38fcbd32013-07-07 19:50:23 +02001161 CPU_FOREACH(cpu) {
1162 cpu->thread_id = qemu_get_thread_id();
1163 cpu->created = true;
Pavel Dovgalyuk626cf8f2014-12-08 10:53:17 +03001164 cpu->can_do_io = 1;
Andreas Färber38fcbd32013-07-07 19:50:23 +02001165 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001166 qemu_cond_signal(&qemu_cpu_cond);
1167
Jan Kiszkafa7d1862011-08-22 18:35:25 +02001168 /* wait for initial kick-off after machine start */
Emilio G. Cotac28e3992015-04-27 12:45:28 -04001169 while (first_cpu->stopped) {
KONRAD Fredericd5f8d612015-08-10 17:27:06 +02001170 qemu_cond_wait(first_cpu->halt_cond, &qemu_global_mutex);
Jan Kiszka8e564b42012-02-17 18:31:15 +01001171
1172 /* process any pending work */
Andreas Färberbdc44642013-06-24 23:50:24 +02001173 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +02001174 qemu_wait_io_event_common(cpu);
Jan Kiszka8e564b42012-02-17 18:31:15 +01001175 }
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001176 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001177
Paolo Bonzini21618b32015-02-27 20:01:03 +01001178 /* process any pending work */
Paolo Bonziniaed807c2015-08-18 06:43:15 -07001179 atomic_mb_set(&exit_request, 1);
Paolo Bonzini21618b32015-02-27 20:01:03 +01001180
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001181 cpu = first_cpu;
1182
Blue Swirl296af7c2010-03-29 19:23:50 +00001183 while (1) {
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001184 /* Account partial waits to QEMU_CLOCK_VIRTUAL. */
1185 qemu_account_warp_timer();
1186
1187 if (!cpu) {
1188 cpu = first_cpu;
1189 }
1190
1191 for (; cpu != NULL && !exit_request; cpu = CPU_NEXT(cpu)) {
1192
1193 qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
1194 (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);
1195
1196 if (cpu_can_run(cpu)) {
1197 int r;
1198 r = tcg_cpu_exec(cpu);
1199 if (r == EXCP_DEBUG) {
1200 cpu_handle_guest_debug(cpu);
1201 break;
1202 }
1203 } else if (cpu->stop || cpu->stopped) {
1204 if (cpu->unplug) {
1205 cpu = CPU_NEXT(cpu);
1206 }
1207 break;
1208 }
1209
1210 } /* for cpu.. */
1211
1212 /* Pairs with smp_wmb in qemu_cpu_kick. */
1213 atomic_mb_set(&exit_request, 0);
Alex Blighac70aaf2013-08-21 16:02:57 +01001214
Alex Bennée12e97002016-10-27 16:10:14 +01001215 handle_icount_deadline();
Alex Blighac70aaf2013-08-21 16:02:57 +01001216
KONRAD Fredericd5f8d612015-08-10 17:27:06 +02001217 qemu_tcg_wait_io_event(QTAILQ_FIRST(&cpus));
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001218 deal_with_unplugged_cpus();
Blue Swirl296af7c2010-03-29 19:23:50 +00001219 }
1220
1221 return NULL;
1222}
1223
Andreas Färber2ff09a42012-05-03 00:23:30 +02001224static void qemu_cpu_kick_thread(CPUState *cpu)
Paolo Bonzinicc015e92011-03-12 17:44:08 +01001225{
1226#ifndef _WIN32
1227 int err;
1228
Paolo Bonzinie0c38212015-08-26 00:19:19 +02001229 if (cpu->thread_kicked) {
1230 return;
Paolo Bonzini9102ded2015-08-18 06:52:09 -07001231 }
Paolo Bonzinie0c38212015-08-26 00:19:19 +02001232 cpu->thread_kicked = true;
Andreas Färber814e6122012-05-02 17:00:37 +02001233 err = pthread_kill(cpu->thread->thread, SIG_IPI);
Paolo Bonzinicc015e92011-03-12 17:44:08 +01001234 if (err) {
1235 fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
1236 exit(1);
1237 }
1238#else /* _WIN32 */
Paolo Bonzinie0c38212015-08-26 00:19:19 +02001239 abort();
Paolo Bonzinicc015e92011-03-12 17:44:08 +01001240#endif
1241}
1242
Paolo Bonzinie0c38212015-08-26 00:19:19 +02001243static void qemu_cpu_kick_no_halt(void)
1244{
1245 CPUState *cpu;
1246 /* Ensure whatever caused the exit has reached the CPU threads before
1247 * writing exit_request.
1248 */
1249 atomic_mb_set(&exit_request, 1);
1250 cpu = atomic_mb_read(&tcg_current_cpu);
1251 if (cpu) {
1252 cpu_exit(cpu);
1253 }
1254}
1255
Andreas Färberc08d7422012-05-03 04:34:15 +02001256void qemu_cpu_kick(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +00001257{
Andreas Färberf5c121b2012-05-03 01:22:49 +02001258 qemu_cond_broadcast(cpu->halt_cond);
Paolo Bonzinie0c38212015-08-26 00:19:19 +02001259 if (tcg_enabled()) {
1260 qemu_cpu_kick_no_halt();
1261 } else {
1262 qemu_cpu_kick_thread(cpu);
1263 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001264}
1265
Jan Kiszka46d62fa2011-02-01 22:15:59 +01001266void qemu_cpu_kick_self(void)
1267{
Andreas Färber4917cf42013-05-27 05:17:50 +02001268 assert(current_cpu);
Paolo Bonzini9102ded2015-08-18 06:52:09 -07001269 qemu_cpu_kick_thread(current_cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +00001270}
1271
Andreas Färber60e82572012-05-02 22:23:49 +02001272bool qemu_cpu_is_self(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +00001273{
Andreas Färber814e6122012-05-02 17:00:37 +02001274 return qemu_thread_is_self(cpu->thread);
Blue Swirl296af7c2010-03-29 19:23:50 +00001275}
1276
Paolo Bonzini79e2b9a2015-01-21 12:09:14 +01001277bool qemu_in_vcpu_thread(void)
Juan Quintelaaa723c22012-09-18 16:30:11 +02001278{
Andreas Färber4917cf42013-05-27 05:17:50 +02001279 return current_cpu && qemu_cpu_is_self(current_cpu);
Juan Quintelaaa723c22012-09-18 16:30:11 +02001280}
1281
Paolo Bonziniafbe7052015-06-18 18:47:19 +02001282static __thread bool iothread_locked = false;
1283
1284bool qemu_mutex_iothread_locked(void)
1285{
1286 return iothread_locked;
1287}
1288
Blue Swirl296af7c2010-03-29 19:23:50 +00001289void qemu_mutex_lock_iothread(void)
1290{
Paolo Bonzini21618b32015-02-27 20:01:03 +01001291 atomic_inc(&iothread_requesting_mutex);
Paolo Bonzini2e7f7a32015-06-18 18:47:18 +02001292 /* In the simple case there is no need to bump the VCPU thread out of
1293 * TCG code execution.
1294 */
1295 if (!tcg_enabled() || qemu_in_vcpu_thread() ||
Aníbal Limón46036b22015-09-03 15:48:33 -05001296 !first_cpu || !first_cpu->created) {
Blue Swirl296af7c2010-03-29 19:23:50 +00001297 qemu_mutex_lock(&qemu_global_mutex);
Paolo Bonzini21618b32015-02-27 20:01:03 +01001298 atomic_dec(&iothread_requesting_mutex);
Marcelo Tosatti1a28cac2010-05-04 09:45:20 -03001299 } else {
Marcelo Tosatti1a28cac2010-05-04 09:45:20 -03001300 if (qemu_mutex_trylock(&qemu_global_mutex)) {
Paolo Bonzinie0c38212015-08-26 00:19:19 +02001301 qemu_cpu_kick_no_halt();
Marcelo Tosatti1a28cac2010-05-04 09:45:20 -03001302 qemu_mutex_lock(&qemu_global_mutex);
1303 }
Paolo Bonzini6b498092015-02-27 19:58:23 +01001304 atomic_dec(&iothread_requesting_mutex);
Paolo Bonzini46daff12011-06-09 13:10:24 +02001305 qemu_cond_broadcast(&qemu_io_proceeded_cond);
Marcelo Tosatti1a28cac2010-05-04 09:45:20 -03001306 }
Paolo Bonziniafbe7052015-06-18 18:47:19 +02001307 iothread_locked = true;
Blue Swirl296af7c2010-03-29 19:23:50 +00001308}
1309
1310void qemu_mutex_unlock_iothread(void)
1311{
Paolo Bonziniafbe7052015-06-18 18:47:19 +02001312 iothread_locked = false;
Blue Swirl296af7c2010-03-29 19:23:50 +00001313 qemu_mutex_unlock(&qemu_global_mutex);
1314}
1315
Alex Bennéee8faee02016-10-27 16:09:58 +01001316static bool all_vcpus_paused(void)
Blue Swirl296af7c2010-03-29 19:23:50 +00001317{
Andreas Färberbdc44642013-06-24 23:50:24 +02001318 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +00001319
Andreas Färberbdc44642013-06-24 23:50:24 +02001320 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +02001321 if (!cpu->stopped) {
Alex Bennéee8faee02016-10-27 16:09:58 +01001322 return false;
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001323 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001324 }
1325
Alex Bennéee8faee02016-10-27 16:09:58 +01001326 return true;
Blue Swirl296af7c2010-03-29 19:23:50 +00001327}
1328
1329void pause_all_vcpus(void)
1330{
Andreas Färberbdc44642013-06-24 23:50:24 +02001331 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +00001332
Alex Bligh40daca52013-08-21 16:03:02 +01001333 qemu_clock_enable(QEMU_CLOCK_VIRTUAL, false);
Andreas Färberbdc44642013-06-24 23:50:24 +02001334 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +02001335 cpu->stop = true;
1336 qemu_cpu_kick(cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +00001337 }
1338
Juan Quintelaaa723c22012-09-18 16:30:11 +02001339 if (qemu_in_vcpu_thread()) {
Jan Kiszkad798e972012-02-17 18:31:16 +01001340 cpu_stop_current();
1341 if (!kvm_enabled()) {
Andreas Färberbdc44642013-06-24 23:50:24 +02001342 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +02001343 cpu->stop = false;
1344 cpu->stopped = true;
Jan Kiszkad798e972012-02-17 18:31:16 +01001345 }
1346 return;
1347 }
1348 }
1349
Blue Swirl296af7c2010-03-29 19:23:50 +00001350 while (!all_vcpus_paused()) {
Paolo Bonzinibe7d6c52011-03-12 17:44:02 +01001351 qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
Andreas Färberbdc44642013-06-24 23:50:24 +02001352 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +02001353 qemu_cpu_kick(cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +00001354 }
1355 }
1356}
1357
Igor Mammedov29936832013-04-23 10:29:37 +02001358void cpu_resume(CPUState *cpu)
1359{
1360 cpu->stop = false;
1361 cpu->stopped = false;
1362 qemu_cpu_kick(cpu);
1363}
1364
Blue Swirl296af7c2010-03-29 19:23:50 +00001365void resume_all_vcpus(void)
1366{
Andreas Färberbdc44642013-06-24 23:50:24 +02001367 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +00001368
Alex Bligh40daca52013-08-21 16:03:02 +01001369 qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
Andreas Färberbdc44642013-06-24 23:50:24 +02001370 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +02001371 cpu_resume(cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +00001372 }
1373}
1374
Gu Zheng4c055ab2016-05-12 09:18:13 +05301375void cpu_remove(CPUState *cpu)
1376{
1377 cpu->stop = true;
1378 cpu->unplug = true;
1379 qemu_cpu_kick(cpu);
1380}
1381
Bharata B Rao2c579042016-05-12 09:18:14 +05301382void cpu_remove_sync(CPUState *cpu)
1383{
1384 cpu_remove(cpu);
1385 while (cpu->created) {
1386 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1387 }
1388}
1389
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001390/* For temporary buffers for forming a name */
1391#define VCPU_THREAD_NAME_SIZE 16
1392
Andreas Färbere5ab30a2012-05-03 01:50:44 +02001393static void qemu_tcg_init_vcpu(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +00001394{
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001395 char thread_name[VCPU_THREAD_NAME_SIZE];
KONRAD Fredericd5f8d612015-08-10 17:27:06 +02001396 static QemuCond *tcg_halt_cond;
1397 static QemuThread *tcg_cpu_thread;
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001398
Blue Swirl296af7c2010-03-29 19:23:50 +00001399 /* share a single thread for all cpus with TCG */
1400 if (!tcg_cpu_thread) {
Andreas Färber814e6122012-05-02 17:00:37 +02001401 cpu->thread = g_malloc0(sizeof(QemuThread));
Andreas Färberf5c121b2012-05-03 01:22:49 +02001402 cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1403 qemu_cond_init(cpu->halt_cond);
1404 tcg_halt_cond = cpu->halt_cond;
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001405 snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/TCG",
1406 cpu->cpu_index);
1407 qemu_thread_create(cpu->thread, thread_name, qemu_tcg_cpu_thread_fn,
1408 cpu, QEMU_THREAD_JOINABLE);
Paolo Bonzini1ecf47b2011-12-13 13:43:52 +01001409#ifdef _WIN32
Andreas Färber814e6122012-05-02 17:00:37 +02001410 cpu->hThread = qemu_thread_get_handle(cpu->thread);
Paolo Bonzini1ecf47b2011-12-13 13:43:52 +01001411#endif
Andreas Färber61a46212012-05-02 22:49:36 +02001412 while (!cpu->created) {
Paolo Bonzini18a85722011-03-12 17:44:03 +01001413 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001414 }
Andreas Färber814e6122012-05-02 17:00:37 +02001415 tcg_cpu_thread = cpu->thread;
Blue Swirl296af7c2010-03-29 19:23:50 +00001416 } else {
Andreas Färber814e6122012-05-02 17:00:37 +02001417 cpu->thread = tcg_cpu_thread;
Andreas Färberf5c121b2012-05-03 01:22:49 +02001418 cpu->halt_cond = tcg_halt_cond;
Blue Swirl296af7c2010-03-29 19:23:50 +00001419 }
1420}
1421
Andreas Färber48a106b2013-05-27 02:20:39 +02001422static void qemu_kvm_start_vcpu(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +00001423{
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001424 char thread_name[VCPU_THREAD_NAME_SIZE];
1425
Andreas Färber814e6122012-05-02 17:00:37 +02001426 cpu->thread = g_malloc0(sizeof(QemuThread));
Andreas Färberf5c121b2012-05-03 01:22:49 +02001427 cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1428 qemu_cond_init(cpu->halt_cond);
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001429 snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/KVM",
1430 cpu->cpu_index);
1431 qemu_thread_create(cpu->thread, thread_name, qemu_kvm_cpu_thread_fn,
1432 cpu, QEMU_THREAD_JOINABLE);
Andreas Färber61a46212012-05-02 22:49:36 +02001433 while (!cpu->created) {
Paolo Bonzini18a85722011-03-12 17:44:03 +01001434 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001435 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001436}
1437
Andreas Färber10a90212013-05-27 02:24:35 +02001438static void qemu_dummy_start_vcpu(CPUState *cpu)
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001439{
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001440 char thread_name[VCPU_THREAD_NAME_SIZE];
1441
Andreas Färber814e6122012-05-02 17:00:37 +02001442 cpu->thread = g_malloc0(sizeof(QemuThread));
Andreas Färberf5c121b2012-05-03 01:22:49 +02001443 cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1444 qemu_cond_init(cpu->halt_cond);
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001445 snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/DUMMY",
1446 cpu->cpu_index);
1447 qemu_thread_create(cpu->thread, thread_name, qemu_dummy_cpu_thread_fn, cpu,
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001448 QEMU_THREAD_JOINABLE);
Andreas Färber61a46212012-05-02 22:49:36 +02001449 while (!cpu->created) {
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001450 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1451 }
1452}
1453
Andreas Färberc643bed2013-05-27 03:23:24 +02001454void qemu_init_vcpu(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +00001455{
Andreas Färberce3960e2012-12-17 03:27:07 +01001456 cpu->nr_cores = smp_cores;
1457 cpu->nr_threads = smp_threads;
Andreas Färberf324e762012-05-02 23:26:21 +02001458 cpu->stopped = true;
Peter Maydell56943e82016-01-21 14:15:04 +00001459
1460 if (!cpu->as) {
1461 /* If the target cpu hasn't set up any address spaces itself,
1462 * give it the default one.
1463 */
Peter Crosthwaite6731d862016-01-21 14:15:06 +00001464 AddressSpace *as = address_space_init_shareable(cpu->memory,
1465 "cpu-memory");
Peter Maydell12ebc9a2016-01-21 14:15:04 +00001466 cpu->num_ases = 1;
Peter Crosthwaite6731d862016-01-21 14:15:06 +00001467 cpu_address_space_init(cpu, as, 0);
Peter Maydell56943e82016-01-21 14:15:04 +00001468 }
1469
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001470 if (kvm_enabled()) {
Andreas Färber48a106b2013-05-27 02:20:39 +02001471 qemu_kvm_start_vcpu(cpu);
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001472 } else if (tcg_enabled()) {
Andreas Färbere5ab30a2012-05-03 01:50:44 +02001473 qemu_tcg_init_vcpu(cpu);
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001474 } else {
Andreas Färber10a90212013-05-27 02:24:35 +02001475 qemu_dummy_start_vcpu(cpu);
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001476 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001477}
1478
Jan Kiszkab4a3d962011-02-01 22:15:43 +01001479void cpu_stop_current(void)
Blue Swirl296af7c2010-03-29 19:23:50 +00001480{
Andreas Färber4917cf42013-05-27 05:17:50 +02001481 if (current_cpu) {
1482 current_cpu->stop = false;
1483 current_cpu->stopped = true;
1484 cpu_exit(current_cpu);
Dr. David Alan Gilbert96bce682016-01-25 10:08:18 +00001485 qemu_cond_broadcast(&qemu_pause_cond);
Jan Kiszkab4a3d962011-02-01 22:15:43 +01001486 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001487}
1488
Kevin Wolf56983462013-07-05 13:49:54 +02001489int vm_stop(RunState state)
Blue Swirl296af7c2010-03-29 19:23:50 +00001490{
Juan Quintelaaa723c22012-09-18 16:30:11 +02001491 if (qemu_in_vcpu_thread()) {
Paolo Bonzini74892d22014-06-05 14:53:58 +02001492 qemu_system_vmstop_request_prepare();
Luiz Capitulino1dfb4dd2011-07-29 14:26:33 -03001493 qemu_system_vmstop_request(state);
Blue Swirl296af7c2010-03-29 19:23:50 +00001494 /*
1495 * FIXME: should not return to device code in case
1496 * vm_stop() has been requested.
1497 */
Jan Kiszkab4a3d962011-02-01 22:15:43 +01001498 cpu_stop_current();
Kevin Wolf56983462013-07-05 13:49:54 +02001499 return 0;
Blue Swirl296af7c2010-03-29 19:23:50 +00001500 }
Kevin Wolf56983462013-07-05 13:49:54 +02001501
1502 return do_vm_stop(state);
Blue Swirl296af7c2010-03-29 19:23:50 +00001503}
1504
Luiz Capitulino8a9236f2011-10-14 11:18:09 -03001505/* does a state transition even if the VM is already stopped,
1506 current state is forgotten forever */
Kevin Wolf56983462013-07-05 13:49:54 +02001507int vm_stop_force_state(RunState state)
Luiz Capitulino8a9236f2011-10-14 11:18:09 -03001508{
1509 if (runstate_is_running()) {
Kevin Wolf56983462013-07-05 13:49:54 +02001510 return vm_stop(state);
Luiz Capitulino8a9236f2011-10-14 11:18:09 -03001511 } else {
1512 runstate_set(state);
Wen Congyangb2780d32015-11-20 17:34:38 +08001513
1514 bdrv_drain_all();
Kevin Wolf594a45c2013-07-18 14:52:19 +02001515 /* Make sure to return an error if the flush in a previous vm_stop()
1516 * failed. */
John Snow22af08e2016-09-22 21:45:51 -04001517 return bdrv_flush_all();
Luiz Capitulino8a9236f2011-10-14 11:18:09 -03001518 }
1519}
1520
Stefan Weil9a78eea2010-10-22 23:03:33 +02001521void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
Blue Swirl262353c2010-05-04 19:55:35 +00001522{
1523 /* XXX: implement xxx_cpu_list for targets that still miss it */
Peter Maydelle916cbf2012-09-05 17:41:08 -03001524#if defined(cpu_list)
1525 cpu_list(f, cpu_fprintf);
Blue Swirl262353c2010-05-04 19:55:35 +00001526#endif
1527}
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03001528
1529CpuInfoList *qmp_query_cpus(Error **errp)
1530{
1531 CpuInfoList *head = NULL, *cur_item = NULL;
Andreas Färber182735e2013-05-29 22:29:20 +02001532 CPUState *cpu;
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03001533
Andreas Färberbdc44642013-06-24 23:50:24 +02001534 CPU_FOREACH(cpu) {
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03001535 CpuInfoList *info;
Andreas Färber182735e2013-05-29 22:29:20 +02001536#if defined(TARGET_I386)
1537 X86CPU *x86_cpu = X86_CPU(cpu);
1538 CPUX86State *env = &x86_cpu->env;
1539#elif defined(TARGET_PPC)
1540 PowerPCCPU *ppc_cpu = POWERPC_CPU(cpu);
1541 CPUPPCState *env = &ppc_cpu->env;
1542#elif defined(TARGET_SPARC)
1543 SPARCCPU *sparc_cpu = SPARC_CPU(cpu);
1544 CPUSPARCState *env = &sparc_cpu->env;
1545#elif defined(TARGET_MIPS)
1546 MIPSCPU *mips_cpu = MIPS_CPU(cpu);
1547 CPUMIPSState *env = &mips_cpu->env;
Bastian Koppelmann48e06fe2014-09-01 12:59:46 +01001548#elif defined(TARGET_TRICORE)
1549 TriCoreCPU *tricore_cpu = TRICORE_CPU(cpu);
1550 CPUTriCoreState *env = &tricore_cpu->env;
Andreas Färber182735e2013-05-29 22:29:20 +02001551#endif
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03001552
Andreas Färbercb446ec2013-05-01 14:24:52 +02001553 cpu_synchronize_state(cpu);
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03001554
1555 info = g_malloc0(sizeof(*info));
1556 info->value = g_malloc0(sizeof(*info->value));
Andreas Färber55e5c282012-12-17 06:18:02 +01001557 info->value->CPU = cpu->cpu_index;
Andreas Färber182735e2013-05-29 22:29:20 +02001558 info->value->current = (cpu == first_cpu);
Andreas Färber259186a2013-01-17 18:51:17 +01001559 info->value->halted = cpu->halted;
Eduardo Habkost58f88d42015-05-08 16:04:22 -03001560 info->value->qom_path = object_get_canonical_path(OBJECT(cpu));
Andreas Färber9f09e182012-05-03 06:59:07 +02001561 info->value->thread_id = cpu->thread_id;
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03001562#if defined(TARGET_I386)
Eric Blake86f4b682015-11-18 01:52:59 -07001563 info->value->arch = CPU_INFO_ARCH_X86;
Eric Blake544a3732016-02-17 23:48:27 -07001564 info->value->u.x86.pc = env->eip + env->segs[R_CS].base;
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03001565#elif defined(TARGET_PPC)
Eric Blake86f4b682015-11-18 01:52:59 -07001566 info->value->arch = CPU_INFO_ARCH_PPC;
Eric Blake544a3732016-02-17 23:48:27 -07001567 info->value->u.ppc.nip = env->nip;
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03001568#elif defined(TARGET_SPARC)
Eric Blake86f4b682015-11-18 01:52:59 -07001569 info->value->arch = CPU_INFO_ARCH_SPARC;
Eric Blake544a3732016-02-17 23:48:27 -07001570 info->value->u.q_sparc.pc = env->pc;
1571 info->value->u.q_sparc.npc = env->npc;
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03001572#elif defined(TARGET_MIPS)
Eric Blake86f4b682015-11-18 01:52:59 -07001573 info->value->arch = CPU_INFO_ARCH_MIPS;
Eric Blake544a3732016-02-17 23:48:27 -07001574 info->value->u.q_mips.PC = env->active_tc.PC;
Bastian Koppelmann48e06fe2014-09-01 12:59:46 +01001575#elif defined(TARGET_TRICORE)
Eric Blake86f4b682015-11-18 01:52:59 -07001576 info->value->arch = CPU_INFO_ARCH_TRICORE;
Eric Blake544a3732016-02-17 23:48:27 -07001577 info->value->u.tricore.PC = env->PC;
Eric Blake86f4b682015-11-18 01:52:59 -07001578#else
1579 info->value->arch = CPU_INFO_ARCH_OTHER;
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03001580#endif
1581
1582 /* XXX: waiting for the qapi to support GSList */
1583 if (!cur_item) {
1584 head = cur_item = info;
1585 } else {
1586 cur_item->next = info;
1587 cur_item = info;
1588 }
1589 }
1590
1591 return head;
1592}
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02001593
1594void qmp_memsave(int64_t addr, int64_t size, const char *filename,
1595 bool has_cpu, int64_t cpu_index, Error **errp)
1596{
1597 FILE *f;
1598 uint32_t l;
Andreas Färber55e5c282012-12-17 06:18:02 +01001599 CPUState *cpu;
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02001600 uint8_t buf[1024];
Borislav Petkov0dc9daf2015-02-08 13:14:38 +01001601 int64_t orig_addr = addr, orig_size = size;
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02001602
1603 if (!has_cpu) {
1604 cpu_index = 0;
1605 }
1606
Andreas Färber151d1322013-02-15 15:41:49 +01001607 cpu = qemu_get_cpu(cpu_index);
1608 if (cpu == NULL) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01001609 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
1610 "a CPU number");
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02001611 return;
1612 }
1613
1614 f = fopen(filename, "wb");
1615 if (!f) {
Luiz Capitulino618da852013-06-07 14:35:06 -04001616 error_setg_file_open(errp, errno, filename);
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02001617 return;
1618 }
1619
1620 while (size != 0) {
1621 l = sizeof(buf);
1622 if (l > size)
1623 l = size;
Aneesh Kumar K.V2f4d0f52013-10-01 21:49:30 +05301624 if (cpu_memory_rw_debug(cpu, addr, buf, l, 0) != 0) {
Borislav Petkov0dc9daf2015-02-08 13:14:38 +01001625 error_setg(errp, "Invalid addr 0x%016" PRIx64 "/size %" PRId64
1626 " specified", orig_addr, orig_size);
Aneesh Kumar K.V2f4d0f52013-10-01 21:49:30 +05301627 goto exit;
1628 }
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02001629 if (fwrite(buf, 1, l, f) != l) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01001630 error_setg(errp, QERR_IO_ERROR);
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02001631 goto exit;
1632 }
1633 addr += l;
1634 size -= l;
1635 }
1636
1637exit:
1638 fclose(f);
1639}
Luiz Capitulino6d3962b2011-11-22 17:26:46 -02001640
1641void qmp_pmemsave(int64_t addr, int64_t size, const char *filename,
1642 Error **errp)
1643{
1644 FILE *f;
1645 uint32_t l;
1646 uint8_t buf[1024];
1647
1648 f = fopen(filename, "wb");
1649 if (!f) {
Luiz Capitulino618da852013-06-07 14:35:06 -04001650 error_setg_file_open(errp, errno, filename);
Luiz Capitulino6d3962b2011-11-22 17:26:46 -02001651 return;
1652 }
1653
1654 while (size != 0) {
1655 l = sizeof(buf);
1656 if (l > size)
1657 l = size;
Stefan Weileb6282f2014-04-07 20:28:23 +02001658 cpu_physical_memory_read(addr, buf, l);
Luiz Capitulino6d3962b2011-11-22 17:26:46 -02001659 if (fwrite(buf, 1, l, f) != l) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01001660 error_setg(errp, QERR_IO_ERROR);
Luiz Capitulino6d3962b2011-11-22 17:26:46 -02001661 goto exit;
1662 }
1663 addr += l;
1664 size -= l;
1665 }
1666
1667exit:
1668 fclose(f);
1669}
Luiz Capitulinoab49ab52011-11-23 12:55:53 -02001670
1671void qmp_inject_nmi(Error **errp)
1672{
Alexey Kardashevskiy9cb805f2014-08-20 22:16:33 +10001673 nmi_monitor_handle(monitor_get_cpu_index(), errp);
Luiz Capitulinoab49ab52011-11-23 12:55:53 -02001674}
Sebastian Tanase27498be2014-07-25 11:56:33 +02001675
1676void dump_drift_info(FILE *f, fprintf_function cpu_fprintf)
1677{
1678 if (!use_icount) {
1679 return;
1680 }
1681
1682 cpu_fprintf(f, "Host - Guest clock %"PRIi64" ms\n",
1683 (cpu_get_clock() - cpu_get_icount())/SCALE_MS);
1684 if (icount_align_option) {
1685 cpu_fprintf(f, "Max guest delay %"PRIi64" ms\n", -max_delay/SCALE_MS);
1686 cpu_fprintf(f, "Max guest advance %"PRIi64" ms\n", max_advance/SCALE_MS);
1687 } else {
1688 cpu_fprintf(f, "Max guest delay NA\n");
1689 cpu_fprintf(f, "Max guest advance NA\n");
1690 }
1691}