blob: 5213351c6d380fcef6208e83a2690f692c8aeccf [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"
36#include "sysemu/kvm.h"
Luiz Capitulinode0b36b2011-09-21 16:38:35 -030037#include "qmp-commands.h"
Paolo Bonzini63c91552016-03-15 13:18:37 +010038#include "exec/exec-all.h"
Blue Swirl296af7c2010-03-29 19:23:50 +000039
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010040#include "qemu/thread.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010041#include "sysemu/cpus.h"
42#include "sysemu/qtest.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010043#include "qemu/main-loop.h"
44#include "qemu/bitmap.h"
Liu Ping Fancb365642013-09-25 14:20:58 +080045#include "qemu/seqlock.h"
Wenchao Xiaa4e15de2014-06-18 08:43:36 +020046#include "qapi-event.h"
Alexey Kardashevskiy9cb805f2014-08-20 22:16:33 +100047#include "hw/nmi.h"
Pavel Dovgalyuk8b427042015-09-17 19:24:05 +030048#include "sysemu/replay.h"
Jan Kiszka0ff0fc12011-06-23 10:15:55 +020049
50#ifndef _WIN32
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010051#include "qemu/compatfd.h"
Jan Kiszka0ff0fc12011-06-23 10:15:55 +020052#endif
Blue Swirl296af7c2010-03-29 19:23:50 +000053
Jan Kiszka6d9cb732011-02-01 22:15:58 +010054#ifdef CONFIG_LINUX
55
56#include <sys/prctl.h>
57
Marcelo Tosattic0532a72010-10-11 15:31:21 -030058#ifndef PR_MCE_KILL
59#define PR_MCE_KILL 33
60#endif
61
Jan Kiszka6d9cb732011-02-01 22:15:58 +010062#ifndef PR_MCE_KILL_SET
63#define PR_MCE_KILL_SET 1
64#endif
65
66#ifndef PR_MCE_KILL_EARLY
67#define PR_MCE_KILL_EARLY 1
68#endif
69
70#endif /* CONFIG_LINUX */
71
Sebastian Tanase27498be2014-07-25 11:56:33 +020072int64_t max_delay;
73int64_t max_advance;
Blue Swirl296af7c2010-03-29 19:23:50 +000074
Jason J. Herne2adcc852015-09-08 13:12:33 -040075/* vcpu throttling controls */
76static QEMUTimer *throttle_timer;
77static unsigned int throttle_percentage;
78
79#define CPU_THROTTLE_PCT_MIN 1
80#define CPU_THROTTLE_PCT_MAX 99
81#define CPU_THROTTLE_TIMESLICE_NS 10000000
82
Tiejun Chen321bc0b2013-08-02 09:43:09 +080083bool cpu_is_stopped(CPUState *cpu)
84{
85 return cpu->stopped || !runstate_is_running();
86}
87
Andreas Färbera98ae1d2013-05-26 23:21:08 +020088static bool cpu_thread_is_idle(CPUState *cpu)
Peter Maydellac873f12012-07-19 16:52:27 +010089{
Andreas Färberc64ca812012-05-03 02:11:45 +020090 if (cpu->stop || cpu->queued_work_first) {
Peter Maydellac873f12012-07-19 16:52:27 +010091 return false;
92 }
Tiejun Chen321bc0b2013-08-02 09:43:09 +080093 if (cpu_is_stopped(cpu)) {
Peter Maydellac873f12012-07-19 16:52:27 +010094 return true;
95 }
Andreas Färber8c2e1b02013-08-25 18:53:55 +020096 if (!cpu->halted || cpu_has_work(cpu) ||
Alexander Graf215e79c2013-04-24 22:24:12 +020097 kvm_halt_in_kernel()) {
Peter Maydellac873f12012-07-19 16:52:27 +010098 return false;
99 }
100 return true;
101}
102
103static bool all_cpu_threads_idle(void)
104{
Andreas Färber182735e2013-05-29 22:29:20 +0200105 CPUState *cpu;
Peter Maydellac873f12012-07-19 16:52:27 +0100106
Andreas Färberbdc44642013-06-24 23:50:24 +0200107 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +0200108 if (!cpu_thread_is_idle(cpu)) {
Peter Maydellac873f12012-07-19 16:52:27 +0100109 return false;
110 }
111 }
112 return true;
113}
114
Blue Swirl296af7c2010-03-29 19:23:50 +0000115/***********************************************************/
Paolo Bonzini946fb272011-09-12 13:57:37 +0200116/* guest cycle counter */
117
Paolo Bonzinia3270e12013-10-07 17:18:15 +0200118/* Protected by TimersState seqlock */
119
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200120static bool icount_sleep = true;
Sebastian Tanase71468392014-07-23 11:47:50 +0200121static int64_t vm_clock_warp_start = -1;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200122/* Conversion factor from emulated instructions to virtual clock ticks. */
123static int icount_time_shift;
124/* Arbitrarily pick 1MIPS as the minimum allowable speed. */
125#define MAX_ICOUNT_SHIFT 10
Paolo Bonzinia3270e12013-10-07 17:18:15 +0200126
Paolo Bonzini946fb272011-09-12 13:57:37 +0200127static QEMUTimer *icount_rt_timer;
128static QEMUTimer *icount_vm_timer;
129static QEMUTimer *icount_warp_timer;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200130
131typedef struct TimersState {
Liu Ping Fancb365642013-09-25 14:20:58 +0800132 /* Protected by BQL. */
Paolo Bonzini946fb272011-09-12 13:57:37 +0200133 int64_t cpu_ticks_prev;
134 int64_t cpu_ticks_offset;
Liu Ping Fancb365642013-09-25 14:20:58 +0800135
136 /* cpu_clock_offset can be read out of BQL, so protect it with
137 * this lock.
138 */
139 QemuSeqLock vm_clock_seqlock;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200140 int64_t cpu_clock_offset;
141 int32_t cpu_ticks_enabled;
142 int64_t dummy;
KONRAD Fredericc96778b2014-08-01 01:37:09 +0200143
144 /* Compensate for varying guest execution speed. */
145 int64_t qemu_icount_bias;
146 /* Only written by TCG thread */
147 int64_t qemu_icount;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200148} TimersState;
149
Liu Ping Fand9cd4002013-07-21 08:43:00 +0000150static TimersState timers_state;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200151
Pavel Dovgalyuk2a629142014-12-08 10:53:45 +0300152int64_t cpu_get_icount_raw(void)
Paolo Bonzini946fb272011-09-12 13:57:37 +0200153{
154 int64_t icount;
Andreas Färber4917cf42013-05-27 05:17:50 +0200155 CPUState *cpu = current_cpu;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200156
KONRAD Fredericc96778b2014-08-01 01:37:09 +0200157 icount = timers_state.qemu_icount;
Andreas Färber4917cf42013-05-27 05:17:50 +0200158 if (cpu) {
Paolo Bonzini414b15c2015-06-24 14:16:26 +0200159 if (!cpu->can_do_io) {
Pavel Dovgalyuk2a629142014-12-08 10:53:45 +0300160 fprintf(stderr, "Bad icount read\n");
161 exit(1);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200162 }
Andreas Färber28ecfd72013-08-26 05:51:49 +0200163 icount -= (cpu->icount_decr.u16.low + cpu->icount_extra);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200164 }
Pavel Dovgalyuk2a629142014-12-08 10:53:45 +0300165 return icount;
166}
167
168/* Return the virtual CPU time, based on the instruction counter. */
169static int64_t cpu_get_icount_locked(void)
170{
171 int64_t icount = cpu_get_icount_raw();
KONRAD Frederic3f031312014-08-01 01:37:15 +0200172 return timers_state.qemu_icount_bias + cpu_icount_to_ns(icount);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200173}
174
Paolo Bonzini17a15f12013-10-03 15:17:25 +0200175int64_t cpu_get_icount(void)
176{
177 int64_t icount;
178 unsigned start;
179
180 do {
181 start = seqlock_read_begin(&timers_state.vm_clock_seqlock);
182 icount = cpu_get_icount_locked();
183 } while (seqlock_read_retry(&timers_state.vm_clock_seqlock, start));
184
185 return icount;
186}
187
KONRAD Frederic3f031312014-08-01 01:37:15 +0200188int64_t cpu_icount_to_ns(int64_t icount)
189{
190 return icount << icount_time_shift;
191}
192
Cao jind90f3cc2016-07-29 19:05:38 +0800193/* return the time elapsed in VM between vm_start and vm_stop. Unless
194 * icount is active, cpu_get_ticks() uses units of the host CPU cycle
195 * counter.
196 *
197 * Caller must hold the BQL
198 */
Paolo Bonzini946fb272011-09-12 13:57:37 +0200199int64_t cpu_get_ticks(void)
200{
Paolo Bonzini5f3e3102013-10-28 17:32:18 +0100201 int64_t ticks;
202
Paolo Bonzini946fb272011-09-12 13:57:37 +0200203 if (use_icount) {
204 return cpu_get_icount();
205 }
Paolo Bonzini5f3e3102013-10-28 17:32:18 +0100206
207 ticks = timers_state.cpu_ticks_offset;
208 if (timers_state.cpu_ticks_enabled) {
Christopher Covington4a7428c2015-09-25 10:42:21 -0400209 ticks += cpu_get_host_ticks();
Paolo Bonzini946fb272011-09-12 13:57:37 +0200210 }
Paolo Bonzini5f3e3102013-10-28 17:32:18 +0100211
212 if (timers_state.cpu_ticks_prev > ticks) {
213 /* Note: non increasing ticks may happen if the host uses
214 software suspend */
215 timers_state.cpu_ticks_offset += timers_state.cpu_ticks_prev - ticks;
216 ticks = timers_state.cpu_ticks_prev;
217 }
218
219 timers_state.cpu_ticks_prev = ticks;
220 return ticks;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200221}
222
Liu Ping Fancb365642013-09-25 14:20:58 +0800223static int64_t cpu_get_clock_locked(void)
224{
Cao jin1d45cea2016-07-29 19:05:37 +0800225 int64_t time;
Liu Ping Fancb365642013-09-25 14:20:58 +0800226
Cao jin1d45cea2016-07-29 19:05:37 +0800227 time = timers_state.cpu_clock_offset;
Paolo Bonzini5f3e3102013-10-28 17:32:18 +0100228 if (timers_state.cpu_ticks_enabled) {
Cao jin1d45cea2016-07-29 19:05:37 +0800229 time += get_clock();
Liu Ping Fancb365642013-09-25 14:20:58 +0800230 }
231
Cao jin1d45cea2016-07-29 19:05:37 +0800232 return time;
Liu Ping Fancb365642013-09-25 14:20:58 +0800233}
234
Cao jind90f3cc2016-07-29 19:05:38 +0800235/* Return the monotonic time elapsed in VM, i.e.,
Peter Maydell8212ff82016-09-15 10:24:22 +0100236 * the time between vm_start and vm_stop
237 */
Paolo Bonzini946fb272011-09-12 13:57:37 +0200238int64_t cpu_get_clock(void)
239{
240 int64_t ti;
Liu Ping Fancb365642013-09-25 14:20:58 +0800241 unsigned start;
242
243 do {
244 start = seqlock_read_begin(&timers_state.vm_clock_seqlock);
245 ti = cpu_get_clock_locked();
246 } while (seqlock_read_retry(&timers_state.vm_clock_seqlock, start));
247
248 return ti;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200249}
250
Liu Ping Fancb365642013-09-25 14:20:58 +0800251/* enable cpu_get_ticks()
Cao jin3224e872016-07-08 18:31:37 +0800252 * Caller must hold BQL which serves as mutex for vm_clock_seqlock.
Liu Ping Fancb365642013-09-25 14:20:58 +0800253 */
Paolo Bonzini946fb272011-09-12 13:57:37 +0200254void cpu_enable_ticks(void)
255{
Liu Ping Fancb365642013-09-25 14:20:58 +0800256 /* Here, the really thing protected by seqlock is cpu_clock_offset. */
Emilio G. Cota03719e42016-06-08 14:55:21 -0400257 seqlock_write_begin(&timers_state.vm_clock_seqlock);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200258 if (!timers_state.cpu_ticks_enabled) {
Christopher Covington4a7428c2015-09-25 10:42:21 -0400259 timers_state.cpu_ticks_offset -= cpu_get_host_ticks();
Paolo Bonzini946fb272011-09-12 13:57:37 +0200260 timers_state.cpu_clock_offset -= get_clock();
261 timers_state.cpu_ticks_enabled = 1;
262 }
Emilio G. Cota03719e42016-06-08 14:55:21 -0400263 seqlock_write_end(&timers_state.vm_clock_seqlock);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200264}
265
266/* disable cpu_get_ticks() : the clock is stopped. You must not call
Liu Ping Fancb365642013-09-25 14:20:58 +0800267 * cpu_get_ticks() after that.
Cao jin3224e872016-07-08 18:31:37 +0800268 * Caller must hold BQL which serves as mutex for vm_clock_seqlock.
Liu Ping Fancb365642013-09-25 14:20:58 +0800269 */
Paolo Bonzini946fb272011-09-12 13:57:37 +0200270void cpu_disable_ticks(void)
271{
Liu Ping Fancb365642013-09-25 14:20:58 +0800272 /* Here, the really thing protected by seqlock is cpu_clock_offset. */
Emilio G. Cota03719e42016-06-08 14:55:21 -0400273 seqlock_write_begin(&timers_state.vm_clock_seqlock);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200274 if (timers_state.cpu_ticks_enabled) {
Christopher Covington4a7428c2015-09-25 10:42:21 -0400275 timers_state.cpu_ticks_offset += cpu_get_host_ticks();
Liu Ping Fancb365642013-09-25 14:20:58 +0800276 timers_state.cpu_clock_offset = cpu_get_clock_locked();
Paolo Bonzini946fb272011-09-12 13:57:37 +0200277 timers_state.cpu_ticks_enabled = 0;
278 }
Emilio G. Cota03719e42016-06-08 14:55:21 -0400279 seqlock_write_end(&timers_state.vm_clock_seqlock);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200280}
281
282/* Correlation between real and virtual time is always going to be
283 fairly approximate, so ignore small variation.
284 When the guest is idle real and virtual time will be aligned in
285 the IO wait loop. */
Rutuja Shah73bcb242016-03-21 21:32:30 +0530286#define ICOUNT_WOBBLE (NANOSECONDS_PER_SECOND / 10)
Paolo Bonzini946fb272011-09-12 13:57:37 +0200287
288static void icount_adjust(void)
289{
290 int64_t cur_time;
291 int64_t cur_icount;
292 int64_t delta;
Paolo Bonzinia3270e12013-10-07 17:18:15 +0200293
294 /* Protected by TimersState mutex. */
Paolo Bonzini946fb272011-09-12 13:57:37 +0200295 static int64_t last_delta;
Paolo Bonzini468cc7c2013-10-07 17:21:51 +0200296
Paolo Bonzini946fb272011-09-12 13:57:37 +0200297 /* If the VM is not running, then do nothing. */
298 if (!runstate_is_running()) {
299 return;
300 }
Paolo Bonzini468cc7c2013-10-07 17:21:51 +0200301
Emilio G. Cota03719e42016-06-08 14:55:21 -0400302 seqlock_write_begin(&timers_state.vm_clock_seqlock);
Paolo Bonzini17a15f12013-10-03 15:17:25 +0200303 cur_time = cpu_get_clock_locked();
304 cur_icount = cpu_get_icount_locked();
Paolo Bonzini468cc7c2013-10-07 17:21:51 +0200305
Paolo Bonzini946fb272011-09-12 13:57:37 +0200306 delta = cur_icount - cur_time;
307 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
308 if (delta > 0
309 && last_delta + ICOUNT_WOBBLE < delta * 2
310 && icount_time_shift > 0) {
311 /* The guest is getting too far ahead. Slow time down. */
312 icount_time_shift--;
313 }
314 if (delta < 0
315 && last_delta - ICOUNT_WOBBLE > delta * 2
316 && icount_time_shift < MAX_ICOUNT_SHIFT) {
317 /* The guest is getting too far behind. Speed time up. */
318 icount_time_shift++;
319 }
320 last_delta = delta;
KONRAD Fredericc96778b2014-08-01 01:37:09 +0200321 timers_state.qemu_icount_bias = cur_icount
322 - (timers_state.qemu_icount << icount_time_shift);
Emilio G. Cota03719e42016-06-08 14:55:21 -0400323 seqlock_write_end(&timers_state.vm_clock_seqlock);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200324}
325
326static void icount_adjust_rt(void *opaque)
327{
Alex Bligh40daca52013-08-21 16:03:02 +0100328 timer_mod(icount_rt_timer,
Pavel Dovgalyuk1979b902015-01-12 15:00:43 +0300329 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT) + 1000);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200330 icount_adjust();
331}
332
333static void icount_adjust_vm(void *opaque)
334{
Alex Bligh40daca52013-08-21 16:03:02 +0100335 timer_mod(icount_vm_timer,
336 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
Rutuja Shah73bcb242016-03-21 21:32:30 +0530337 NANOSECONDS_PER_SECOND / 10);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200338 icount_adjust();
339}
340
341static int64_t qemu_icount_round(int64_t count)
342{
343 return (count + (1 << icount_time_shift) - 1) >> icount_time_shift;
344}
345
Pavel Dovgalyukefab87c2015-09-17 19:24:39 +0300346static void icount_warp_rt(void)
Paolo Bonzini946fb272011-09-12 13:57:37 +0200347{
Alex Bennéeccffff42016-04-04 15:35:48 +0100348 unsigned seq;
349 int64_t warp_start;
350
Paolo Bonzini17a15f12013-10-03 15:17:25 +0200351 /* The icount_warp_timer is rescheduled soon after vm_clock_warp_start
352 * changes from -1 to another value, so the race here is okay.
353 */
Alex Bennéeccffff42016-04-04 15:35:48 +0100354 do {
355 seq = seqlock_read_begin(&timers_state.vm_clock_seqlock);
356 warp_start = vm_clock_warp_start;
357 } while (seqlock_read_retry(&timers_state.vm_clock_seqlock, seq));
358
359 if (warp_start == -1) {
Paolo Bonzini946fb272011-09-12 13:57:37 +0200360 return;
361 }
362
Emilio G. Cota03719e42016-06-08 14:55:21 -0400363 seqlock_write_begin(&timers_state.vm_clock_seqlock);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200364 if (runstate_is_running()) {
Pavel Dovgalyuk8eda2062015-09-17 19:24:28 +0300365 int64_t clock = REPLAY_CLOCK(REPLAY_CLOCK_VIRTUAL_RT,
366 cpu_get_clock_locked());
Paolo Bonzini8ed961d2013-10-07 17:26:07 +0200367 int64_t warp_delta;
368
369 warp_delta = clock - vm_clock_warp_start;
370 if (use_icount == 2) {
Paolo Bonzini946fb272011-09-12 13:57:37 +0200371 /*
Alex Bligh40daca52013-08-21 16:03:02 +0100372 * In adaptive mode, do not let QEMU_CLOCK_VIRTUAL run too
Paolo Bonzini946fb272011-09-12 13:57:37 +0200373 * far ahead of real time.
374 */
Paolo Bonzini17a15f12013-10-03 15:17:25 +0200375 int64_t cur_icount = cpu_get_icount_locked();
Pavel Dovgalyukbf2a7dd2014-11-26 13:40:55 +0300376 int64_t delta = clock - cur_icount;
Paolo Bonzini8ed961d2013-10-07 17:26:07 +0200377 warp_delta = MIN(warp_delta, delta);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200378 }
KONRAD Fredericc96778b2014-08-01 01:37:09 +0200379 timers_state.qemu_icount_bias += warp_delta;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200380 }
381 vm_clock_warp_start = -1;
Emilio G. Cota03719e42016-06-08 14:55:21 -0400382 seqlock_write_end(&timers_state.vm_clock_seqlock);
Paolo Bonzini8ed961d2013-10-07 17:26:07 +0200383
384 if (qemu_clock_expired(QEMU_CLOCK_VIRTUAL)) {
385 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
386 }
Paolo Bonzini946fb272011-09-12 13:57:37 +0200387}
388
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300389static void icount_timer_cb(void *opaque)
Pavel Dovgalyukefab87c2015-09-17 19:24:39 +0300390{
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300391 /* No need for a checkpoint because the timer already synchronizes
392 * with CHECKPOINT_CLOCK_VIRTUAL_RT.
393 */
394 icount_warp_rt();
Pavel Dovgalyukefab87c2015-09-17 19:24:39 +0300395}
396
Paolo Bonzini8156be52012-03-28 15:42:04 +0200397void qtest_clock_warp(int64_t dest)
398{
Alex Bligh40daca52013-08-21 16:03:02 +0100399 int64_t clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
Fam Zhengefef88b2015-01-19 17:51:43 +0800400 AioContext *aio_context;
Paolo Bonzini8156be52012-03-28 15:42:04 +0200401 assert(qtest_enabled());
Fam Zhengefef88b2015-01-19 17:51:43 +0800402 aio_context = qemu_get_aio_context();
Paolo Bonzini8156be52012-03-28 15:42:04 +0200403 while (clock < dest) {
Alex Bligh40daca52013-08-21 16:03:02 +0100404 int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
Sergey Fedorovc9299e22014-06-10 13:10:28 +0400405 int64_t warp = qemu_soonest_timeout(dest - clock, deadline);
Fam Zhengefef88b2015-01-19 17:51:43 +0800406
Emilio G. Cota03719e42016-06-08 14:55:21 -0400407 seqlock_write_begin(&timers_state.vm_clock_seqlock);
KONRAD Fredericc96778b2014-08-01 01:37:09 +0200408 timers_state.qemu_icount_bias += warp;
Emilio G. Cota03719e42016-06-08 14:55:21 -0400409 seqlock_write_end(&timers_state.vm_clock_seqlock);
Paolo Bonzini17a15f12013-10-03 15:17:25 +0200410
Alex Bligh40daca52013-08-21 16:03:02 +0100411 qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
Fam Zhengefef88b2015-01-19 17:51:43 +0800412 timerlist_run_timers(aio_context->tlg.tl[QEMU_CLOCK_VIRTUAL]);
Alex Bligh40daca52013-08-21 16:03:02 +0100413 clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
Paolo Bonzini8156be52012-03-28 15:42:04 +0200414 }
Alex Bligh40daca52013-08-21 16:03:02 +0100415 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
Paolo Bonzini8156be52012-03-28 15:42:04 +0200416}
417
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300418void qemu_start_warp_timer(void)
Paolo Bonzini946fb272011-09-12 13:57:37 +0200419{
Paolo Bonzinice78d182013-10-07 17:30:02 +0200420 int64_t clock;
Paolo Bonzini946fb272011-09-12 13:57:37 +0200421 int64_t deadline;
422
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300423 if (!use_icount) {
Paolo Bonzini946fb272011-09-12 13:57:37 +0200424 return;
425 }
426
Pavel Dovgalyuk8bd7f712015-09-17 19:24:44 +0300427 /* Nothing to do if the VM is stopped: QEMU_CLOCK_VIRTUAL timers
428 * do not fire, so computing the deadline does not make sense.
429 */
430 if (!runstate_is_running()) {
431 return;
432 }
433
434 /* warp clock deterministically in record/replay mode */
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300435 if (!replay_checkpoint(CHECKPOINT_CLOCK_WARP_START)) {
Pavel Dovgalyuk8bd7f712015-09-17 19:24:44 +0300436 return;
437 }
438
Paolo Bonzinice78d182013-10-07 17:30:02 +0200439 if (!all_cpu_threads_idle()) {
Paolo Bonzini946fb272011-09-12 13:57:37 +0200440 return;
441 }
442
Paolo Bonzini8156be52012-03-28 15:42:04 +0200443 if (qtest_enabled()) {
444 /* When testing, qtest commands advance icount. */
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300445 return;
Paolo Bonzini8156be52012-03-28 15:42:04 +0200446 }
447
Alex Blighac70aaf2013-08-21 16:02:57 +0100448 /* We want to use the earliest deadline from ALL vm_clocks */
Pavel Dovgalyukbf2a7dd2014-11-26 13:40:55 +0300449 clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT);
Alex Bligh40daca52013-08-21 16:03:02 +0100450 deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
Paolo Bonzinice78d182013-10-07 17:30:02 +0200451 if (deadline < 0) {
Victor CLEMENTd7a0f712015-05-29 17:14:06 +0200452 static bool notified;
453 if (!icount_sleep && !notified) {
454 error_report("WARNING: icount sleep disabled and no active timers");
455 notified = true;
456 }
Paolo Bonzinice78d182013-10-07 17:30:02 +0200457 return;
Alex Blighac70aaf2013-08-21 16:02:57 +0100458 }
459
Paolo Bonzini946fb272011-09-12 13:57:37 +0200460 if (deadline > 0) {
461 /*
Alex Bligh40daca52013-08-21 16:03:02 +0100462 * Ensure QEMU_CLOCK_VIRTUAL proceeds even when the virtual CPU goes to
Paolo Bonzini946fb272011-09-12 13:57:37 +0200463 * sleep. Otherwise, the CPU might be waiting for a future timer
464 * interrupt to wake it up, but the interrupt never comes because
465 * the vCPU isn't running any insns and thus doesn't advance the
Alex Bligh40daca52013-08-21 16:03:02 +0100466 * QEMU_CLOCK_VIRTUAL.
Paolo Bonzini946fb272011-09-12 13:57:37 +0200467 */
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200468 if (!icount_sleep) {
469 /*
470 * We never let VCPUs sleep in no sleep icount mode.
471 * If there is a pending QEMU_CLOCK_VIRTUAL timer we just advance
472 * to the next QEMU_CLOCK_VIRTUAL event and notify it.
473 * It is useful when we want a deterministic execution time,
474 * isolated from host latencies.
475 */
Emilio G. Cota03719e42016-06-08 14:55:21 -0400476 seqlock_write_begin(&timers_state.vm_clock_seqlock);
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200477 timers_state.qemu_icount_bias += deadline;
Emilio G. Cota03719e42016-06-08 14:55:21 -0400478 seqlock_write_end(&timers_state.vm_clock_seqlock);
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200479 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
480 } else {
481 /*
482 * We do stop VCPUs and only advance QEMU_CLOCK_VIRTUAL after some
483 * "real" time, (related to the time left until the next event) has
484 * passed. The QEMU_CLOCK_VIRTUAL_RT clock will do this.
485 * This avoids that the warps are visible externally; for example,
486 * you will not be sending network packets continuously instead of
487 * every 100ms.
488 */
Emilio G. Cota03719e42016-06-08 14:55:21 -0400489 seqlock_write_begin(&timers_state.vm_clock_seqlock);
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200490 if (vm_clock_warp_start == -1 || vm_clock_warp_start > clock) {
491 vm_clock_warp_start = clock;
492 }
Emilio G. Cota03719e42016-06-08 14:55:21 -0400493 seqlock_write_end(&timers_state.vm_clock_seqlock);
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200494 timer_mod_anticipate(icount_warp_timer, clock + deadline);
Paolo Bonzinice78d182013-10-07 17:30:02 +0200495 }
Alex Blighac70aaf2013-08-21 16:02:57 +0100496 } else if (deadline == 0) {
Alex Bligh40daca52013-08-21 16:03:02 +0100497 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200498 }
499}
500
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300501static void qemu_account_warp_timer(void)
502{
503 if (!use_icount || !icount_sleep) {
504 return;
505 }
506
507 /* Nothing to do if the VM is stopped: QEMU_CLOCK_VIRTUAL timers
508 * do not fire, so computing the deadline does not make sense.
509 */
510 if (!runstate_is_running()) {
511 return;
512 }
513
514 /* warp clock deterministically in record/replay mode */
515 if (!replay_checkpoint(CHECKPOINT_CLOCK_WARP_ACCOUNT)) {
516 return;
517 }
518
519 timer_del(icount_warp_timer);
520 icount_warp_rt();
521}
522
KONRAD Fredericd09eae32014-08-01 01:37:10 +0200523static bool icount_state_needed(void *opaque)
524{
525 return use_icount;
526}
527
528/*
529 * This is a subsection for icount migration.
530 */
531static const VMStateDescription icount_vmstate_timers = {
532 .name = "timer/icount",
533 .version_id = 1,
534 .minimum_version_id = 1,
Juan Quintela5cd8cad2014-09-23 14:09:54 +0200535 .needed = icount_state_needed,
KONRAD Fredericd09eae32014-08-01 01:37:10 +0200536 .fields = (VMStateField[]) {
537 VMSTATE_INT64(qemu_icount_bias, TimersState),
538 VMSTATE_INT64(qemu_icount, TimersState),
539 VMSTATE_END_OF_LIST()
540 }
541};
542
Paolo Bonzini946fb272011-09-12 13:57:37 +0200543static const VMStateDescription vmstate_timers = {
544 .name = "timer",
545 .version_id = 2,
546 .minimum_version_id = 1,
Juan Quintela35d08452014-04-16 16:01:33 +0200547 .fields = (VMStateField[]) {
Paolo Bonzini946fb272011-09-12 13:57:37 +0200548 VMSTATE_INT64(cpu_ticks_offset, TimersState),
549 VMSTATE_INT64(dummy, TimersState),
550 VMSTATE_INT64_V(cpu_clock_offset, TimersState, 2),
551 VMSTATE_END_OF_LIST()
KONRAD Fredericd09eae32014-08-01 01:37:10 +0200552 },
Juan Quintela5cd8cad2014-09-23 14:09:54 +0200553 .subsections = (const VMStateDescription*[]) {
554 &icount_vmstate_timers,
555 NULL
Paolo Bonzini946fb272011-09-12 13:57:37 +0200556 }
557};
558
Paolo Bonzini14e6fe12016-10-31 10:36:08 +0100559static void cpu_throttle_thread(CPUState *cpu, run_on_cpu_data opaque)
Jason J. Herne2adcc852015-09-08 13:12:33 -0400560{
Jason J. Herne2adcc852015-09-08 13:12:33 -0400561 double pct;
562 double throttle_ratio;
563 long sleeptime_ns;
564
565 if (!cpu_throttle_get_percentage()) {
566 return;
567 }
568
569 pct = (double)cpu_throttle_get_percentage()/100;
570 throttle_ratio = pct / (1 - pct);
571 sleeptime_ns = (long)(throttle_ratio * CPU_THROTTLE_TIMESLICE_NS);
572
573 qemu_mutex_unlock_iothread();
574 atomic_set(&cpu->throttle_thread_scheduled, 0);
575 g_usleep(sleeptime_ns / 1000); /* Convert ns to us for usleep call */
576 qemu_mutex_lock_iothread();
577}
578
579static void cpu_throttle_timer_tick(void *opaque)
580{
581 CPUState *cpu;
582 double pct;
583
584 /* Stop the timer if needed */
585 if (!cpu_throttle_get_percentage()) {
586 return;
587 }
588 CPU_FOREACH(cpu) {
589 if (!atomic_xchg(&cpu->throttle_thread_scheduled, 1)) {
Paolo Bonzini14e6fe12016-10-31 10:36:08 +0100590 async_run_on_cpu(cpu, cpu_throttle_thread,
591 RUN_ON_CPU_NULL);
Jason J. Herne2adcc852015-09-08 13:12:33 -0400592 }
593 }
594
595 pct = (double)cpu_throttle_get_percentage()/100;
596 timer_mod(throttle_timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT) +
597 CPU_THROTTLE_TIMESLICE_NS / (1-pct));
598}
599
600void cpu_throttle_set(int new_throttle_pct)
601{
602 /* Ensure throttle percentage is within valid range */
603 new_throttle_pct = MIN(new_throttle_pct, CPU_THROTTLE_PCT_MAX);
604 new_throttle_pct = MAX(new_throttle_pct, CPU_THROTTLE_PCT_MIN);
605
606 atomic_set(&throttle_percentage, new_throttle_pct);
607
608 timer_mod(throttle_timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT) +
609 CPU_THROTTLE_TIMESLICE_NS);
610}
611
612void cpu_throttle_stop(void)
613{
614 atomic_set(&throttle_percentage, 0);
615}
616
617bool cpu_throttle_active(void)
618{
619 return (cpu_throttle_get_percentage() != 0);
620}
621
622int cpu_throttle_get_percentage(void)
623{
624 return atomic_read(&throttle_percentage);
625}
626
Pavel Dovgalyuk4603ea02014-09-01 09:34:49 +0400627void cpu_ticks_init(void)
628{
Emilio G. Cotaccdb3c12016-06-08 14:55:20 -0400629 seqlock_init(&timers_state.vm_clock_seqlock);
Pavel Dovgalyuk4603ea02014-09-01 09:34:49 +0400630 vmstate_register(NULL, 0, &vmstate_timers, &timers_state);
Jason J. Herne2adcc852015-09-08 13:12:33 -0400631 throttle_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL_RT,
632 cpu_throttle_timer_tick, NULL);
Pavel Dovgalyuk4603ea02014-09-01 09:34:49 +0400633}
634
Sebastian Tanase1ad95802014-07-25 11:56:28 +0200635void configure_icount(QemuOpts *opts, Error **errp)
Paolo Bonzini946fb272011-09-12 13:57:37 +0200636{
Sebastian Tanase1ad95802014-07-25 11:56:28 +0200637 const char *option;
Sebastian Tanasea8bfac32014-07-25 11:56:29 +0200638 char *rem_str = NULL;
Sebastian Tanase1ad95802014-07-25 11:56:28 +0200639
Sebastian Tanase1ad95802014-07-25 11:56:28 +0200640 option = qemu_opt_get(opts, "shift");
Paolo Bonzini946fb272011-09-12 13:57:37 +0200641 if (!option) {
Sebastian Tanasea8bfac32014-07-25 11:56:29 +0200642 if (qemu_opt_get(opts, "align") != NULL) {
643 error_setg(errp, "Please specify shift option when using align");
644 }
Paolo Bonzini946fb272011-09-12 13:57:37 +0200645 return;
646 }
Victor CLEMENTf1f4b572015-05-29 17:14:05 +0200647
648 icount_sleep = qemu_opt_get_bool(opts, "sleep", true);
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200649 if (icount_sleep) {
650 icount_warp_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL_RT,
Pavel Dovgalyuke76d1792016-03-10 14:56:09 +0300651 icount_timer_cb, NULL);
Victor CLEMENT5045e9d92015-05-29 17:14:04 +0200652 }
Victor CLEMENTf1f4b572015-05-29 17:14:05 +0200653
Sebastian Tanasea8bfac32014-07-25 11:56:29 +0200654 icount_align_option = qemu_opt_get_bool(opts, "align", false);
Victor CLEMENTf1f4b572015-05-29 17:14:05 +0200655
656 if (icount_align_option && !icount_sleep) {
Pranith Kumar778d9f92016-02-26 10:16:51 -0500657 error_setg(errp, "align=on and sleep=off are incompatible");
Victor CLEMENTf1f4b572015-05-29 17:14:05 +0200658 }
Paolo Bonzini946fb272011-09-12 13:57:37 +0200659 if (strcmp(option, "auto") != 0) {
Sebastian Tanasea8bfac32014-07-25 11:56:29 +0200660 errno = 0;
661 icount_time_shift = strtol(option, &rem_str, 0);
662 if (errno != 0 || *rem_str != '\0' || !strlen(option)) {
663 error_setg(errp, "icount: Invalid shift value");
664 }
Paolo Bonzini946fb272011-09-12 13:57:37 +0200665 use_icount = 1;
666 return;
Sebastian Tanasea8bfac32014-07-25 11:56:29 +0200667 } else if (icount_align_option) {
668 error_setg(errp, "shift=auto and align=on are incompatible");
Victor CLEMENTf1f4b572015-05-29 17:14:05 +0200669 } else if (!icount_sleep) {
Pranith Kumar778d9f92016-02-26 10:16:51 -0500670 error_setg(errp, "shift=auto and sleep=off are incompatible");
Paolo Bonzini946fb272011-09-12 13:57:37 +0200671 }
672
673 use_icount = 2;
674
675 /* 125MIPS seems a reasonable initial guess at the guest speed.
676 It will be corrected fairly quickly anyway. */
677 icount_time_shift = 3;
678
679 /* Have both realtime and virtual time triggers for speed adjustment.
680 The realtime trigger catches emulated time passing too slowly,
681 the virtual time trigger catches emulated time passing too fast.
682 Realtime triggers occur even when idle, so use them less frequently
683 than VM triggers. */
Pavel Dovgalyukbf2a7dd2014-11-26 13:40:55 +0300684 icount_rt_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL_RT,
685 icount_adjust_rt, NULL);
Alex Bligh40daca52013-08-21 16:03:02 +0100686 timer_mod(icount_rt_timer,
Pavel Dovgalyukbf2a7dd2014-11-26 13:40:55 +0300687 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT) + 1000);
Alex Bligh40daca52013-08-21 16:03:02 +0100688 icount_vm_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
689 icount_adjust_vm, NULL);
690 timer_mod(icount_vm_timer,
691 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
Rutuja Shah73bcb242016-03-21 21:32:30 +0530692 NANOSECONDS_PER_SECOND / 10);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200693}
694
695/***********************************************************/
Blue Swirl296af7c2010-03-29 19:23:50 +0000696void hw_error(const char *fmt, ...)
697{
698 va_list ap;
Andreas Färber55e5c282012-12-17 06:18:02 +0100699 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +0000700
701 va_start(ap, fmt);
702 fprintf(stderr, "qemu: hardware error: ");
703 vfprintf(stderr, fmt, ap);
704 fprintf(stderr, "\n");
Andreas Färberbdc44642013-06-24 23:50:24 +0200705 CPU_FOREACH(cpu) {
Andreas Färber55e5c282012-12-17 06:18:02 +0100706 fprintf(stderr, "CPU #%d:\n", cpu->cpu_index);
Andreas Färber878096e2013-05-27 01:33:50 +0200707 cpu_dump_state(cpu, stderr, fprintf, CPU_DUMP_FPU);
Blue Swirl296af7c2010-03-29 19:23:50 +0000708 }
709 va_end(ap);
710 abort();
711}
712
713void cpu_synchronize_all_states(void)
714{
Andreas Färber182735e2013-05-29 22:29:20 +0200715 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +0000716
Andreas Färberbdc44642013-06-24 23:50:24 +0200717 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +0200718 cpu_synchronize_state(cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +0000719 }
720}
721
722void cpu_synchronize_all_post_reset(void)
723{
Andreas Färber182735e2013-05-29 22:29:20 +0200724 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +0000725
Andreas Färberbdc44642013-06-24 23:50:24 +0200726 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +0200727 cpu_synchronize_post_reset(cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +0000728 }
729}
730
731void cpu_synchronize_all_post_init(void)
732{
Andreas Färber182735e2013-05-29 22:29:20 +0200733 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +0000734
Andreas Färberbdc44642013-06-24 23:50:24 +0200735 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +0200736 cpu_synchronize_post_init(cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +0000737 }
738}
739
Kevin Wolf56983462013-07-05 13:49:54 +0200740static int do_vm_stop(RunState state)
Blue Swirl296af7c2010-03-29 19:23:50 +0000741{
Kevin Wolf56983462013-07-05 13:49:54 +0200742 int ret = 0;
743
Luiz Capitulino13548692011-07-29 15:36:43 -0300744 if (runstate_is_running()) {
Blue Swirl296af7c2010-03-29 19:23:50 +0000745 cpu_disable_ticks();
Blue Swirl296af7c2010-03-29 19:23:50 +0000746 pause_all_vcpus();
Luiz Capitulinof5bbfba2011-07-29 15:04:45 -0300747 runstate_set(state);
Luiz Capitulino1dfb4dd2011-07-29 14:26:33 -0300748 vm_state_notify(0, state);
Wenchao Xiaa4e15de2014-06-18 08:43:36 +0200749 qapi_event_send_stop(&error_abort);
Blue Swirl296af7c2010-03-29 19:23:50 +0000750 }
Kevin Wolf56983462013-07-05 13:49:54 +0200751
Kevin Wolf594a45c2013-07-18 14:52:19 +0200752 bdrv_drain_all();
Pavel Dovgalyuk6d0ceb82016-09-26 11:08:16 +0300753 replay_disable_events();
John Snow22af08e2016-09-22 21:45:51 -0400754 ret = bdrv_flush_all();
Kevin Wolf594a45c2013-07-18 14:52:19 +0200755
Kevin Wolf56983462013-07-05 13:49:54 +0200756 return ret;
Blue Swirl296af7c2010-03-29 19:23:50 +0000757}
758
Andreas Färbera1fcaa72012-05-02 23:42:26 +0200759static bool cpu_can_run(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +0000760{
Andreas Färber4fdeee72012-05-02 23:10:09 +0200761 if (cpu->stop) {
Andreas Färbera1fcaa72012-05-02 23:42:26 +0200762 return false;
Jan Kiszka0ab07c62011-02-07 12:19:14 +0100763 }
Tiejun Chen321bc0b2013-08-02 09:43:09 +0800764 if (cpu_is_stopped(cpu)) {
Andreas Färbera1fcaa72012-05-02 23:42:26 +0200765 return false;
Jan Kiszka0ab07c62011-02-07 12:19:14 +0100766 }
Andreas Färbera1fcaa72012-05-02 23:42:26 +0200767 return true;
Blue Swirl296af7c2010-03-29 19:23:50 +0000768}
769
Andreas Färber91325042013-05-27 02:07:49 +0200770static void cpu_handle_guest_debug(CPUState *cpu)
Jan Kiszka3c638d02010-06-25 16:56:56 +0200771{
Andreas Färber64f6b342013-05-27 02:06:09 +0200772 gdb_set_stop_cpu(cpu);
Jan Kiszka8cf71712011-02-07 12:19:16 +0100773 qemu_system_debug_request();
Andreas Färberf324e762012-05-02 23:26:21 +0200774 cpu->stopped = true;
Jan Kiszka3c638d02010-06-25 16:56:56 +0200775}
776
Jan Kiszka6d9cb732011-02-01 22:15:58 +0100777#ifdef CONFIG_LINUX
778static void sigbus_reraise(void)
779{
780 sigset_t set;
781 struct sigaction action;
782
783 memset(&action, 0, sizeof(action));
784 action.sa_handler = SIG_DFL;
785 if (!sigaction(SIGBUS, &action, NULL)) {
786 raise(SIGBUS);
787 sigemptyset(&set);
788 sigaddset(&set, SIGBUS);
Peter Maydella2d17612016-05-16 18:33:59 +0100789 pthread_sigmask(SIG_UNBLOCK, &set, NULL);
Jan Kiszka6d9cb732011-02-01 22:15:58 +0100790 }
791 perror("Failed to re-raise SIGBUS!\n");
792 abort();
793}
794
795static void sigbus_handler(int n, struct qemu_signalfd_siginfo *siginfo,
796 void *ctx)
797{
798 if (kvm_on_sigbus(siginfo->ssi_code,
799 (void *)(intptr_t)siginfo->ssi_addr)) {
800 sigbus_reraise();
801 }
802}
803
804static void qemu_init_sigbus(void)
805{
806 struct sigaction action;
807
808 memset(&action, 0, sizeof(action));
809 action.sa_flags = SA_SIGINFO;
810 action.sa_sigaction = (void (*)(int, siginfo_t*, void*))sigbus_handler;
811 sigaction(SIGBUS, &action, NULL);
812
813 prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, 0, 0);
814}
815
Andreas Färber290adf32013-01-17 09:30:27 +0100816static void qemu_kvm_eat_signals(CPUState *cpu)
Jan Kiszka1ab3c6c2011-03-15 12:26:12 +0100817{
818 struct timespec ts = { 0, 0 };
819 siginfo_t siginfo;
820 sigset_t waitset;
821 sigset_t chkset;
822 int r;
823
824 sigemptyset(&waitset);
825 sigaddset(&waitset, SIG_IPI);
826 sigaddset(&waitset, SIGBUS);
827
828 do {
829 r = sigtimedwait(&waitset, &siginfo, &ts);
830 if (r == -1 && !(errno == EAGAIN || errno == EINTR)) {
831 perror("sigtimedwait");
832 exit(1);
833 }
834
835 switch (r) {
836 case SIGBUS:
Andreas Färber290adf32013-01-17 09:30:27 +0100837 if (kvm_on_sigbus_vcpu(cpu, siginfo.si_code, siginfo.si_addr)) {
Jan Kiszka1ab3c6c2011-03-15 12:26:12 +0100838 sigbus_reraise();
839 }
840 break;
841 default:
842 break;
843 }
844
845 r = sigpending(&chkset);
846 if (r == -1) {
847 perror("sigpending");
848 exit(1);
849 }
850 } while (sigismember(&chkset, SIG_IPI) || sigismember(&chkset, SIGBUS));
Jan Kiszka1ab3c6c2011-03-15 12:26:12 +0100851}
852
Jan Kiszka6d9cb732011-02-01 22:15:58 +0100853#else /* !CONFIG_LINUX */
854
855static void qemu_init_sigbus(void)
856{
857}
Jan Kiszka1ab3c6c2011-03-15 12:26:12 +0100858
Andreas Färber290adf32013-01-17 09:30:27 +0100859static void qemu_kvm_eat_signals(CPUState *cpu)
Jan Kiszka1ab3c6c2011-03-15 12:26:12 +0100860{
861}
Jan Kiszka6d9cb732011-02-01 22:15:58 +0100862#endif /* !CONFIG_LINUX */
863
Blue Swirl296af7c2010-03-29 19:23:50 +0000864#ifndef _WIN32
Jan Kiszka55f8d6a2011-02-01 22:15:52 +0100865static void dummy_signal(int sig)
Blue Swirl296af7c2010-03-29 19:23:50 +0000866{
867}
868
Andreas Färber13618e02013-05-26 23:41:00 +0200869static void qemu_kvm_init_cpu_signals(CPUState *cpu)
Paolo Bonzini714bd042011-03-12 17:44:06 +0100870{
871 int r;
872 sigset_t set;
873 struct sigaction sigact;
874
875 memset(&sigact, 0, sizeof(sigact));
876 sigact.sa_handler = dummy_signal;
877 sigaction(SIG_IPI, &sigact, NULL);
878
Paolo Bonzini714bd042011-03-12 17:44:06 +0100879 pthread_sigmask(SIG_BLOCK, NULL, &set);
880 sigdelset(&set, SIG_IPI);
881 sigdelset(&set, SIGBUS);
Andreas Färber491d6e82013-05-26 23:38:10 +0200882 r = kvm_set_signal_mask(cpu, &set);
Paolo Bonzini714bd042011-03-12 17:44:06 +0100883 if (r) {
884 fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));
885 exit(1);
886 }
Paolo Bonzini714bd042011-03-12 17:44:06 +0100887}
888
Jan Kiszka55f8d6a2011-02-01 22:15:52 +0100889#else /* _WIN32 */
Andreas Färber13618e02013-05-26 23:41:00 +0200890static void qemu_kvm_init_cpu_signals(CPUState *cpu)
Paolo Bonzini714bd042011-03-12 17:44:06 +0100891{
892 abort();
893}
Jan Kiszka55f8d6a2011-02-01 22:15:52 +0100894#endif /* _WIN32 */
Blue Swirl296af7c2010-03-29 19:23:50 +0000895
Stefan Weilb2532d82012-09-27 07:41:42 +0200896static QemuMutex qemu_global_mutex;
Paolo Bonzini46daff12011-06-09 13:10:24 +0200897static QemuCond qemu_io_proceeded_cond;
Paolo Bonzini6b498092015-02-27 19:58:23 +0100898static unsigned iothread_requesting_mutex;
Blue Swirl296af7c2010-03-29 19:23:50 +0000899
900static QemuThread io_thread;
901
Blue Swirl296af7c2010-03-29 19:23:50 +0000902/* cpu creation */
903static QemuCond qemu_cpu_cond;
904/* system init */
Blue Swirl296af7c2010-03-29 19:23:50 +0000905static QemuCond qemu_pause_cond;
906
Paolo Bonzinid3b12f52011-09-13 10:30:52 +0200907void qemu_init_cpu_loop(void)
Blue Swirl296af7c2010-03-29 19:23:50 +0000908{
Jan Kiszka6d9cb732011-02-01 22:15:58 +0100909 qemu_init_sigbus();
Anthony Liguoried945922011-02-08 18:18:18 +0100910 qemu_cond_init(&qemu_cpu_cond);
Anthony Liguoried945922011-02-08 18:18:18 +0100911 qemu_cond_init(&qemu_pause_cond);
Paolo Bonzini46daff12011-06-09 13:10:24 +0200912 qemu_cond_init(&qemu_io_proceeded_cond);
Blue Swirl296af7c2010-03-29 19:23:50 +0000913 qemu_mutex_init(&qemu_global_mutex);
Blue Swirl296af7c2010-03-29 19:23:50 +0000914
Jan Kiszkab7680cb2011-03-12 17:43:51 +0100915 qemu_thread_get_self(&io_thread);
Blue Swirl296af7c2010-03-29 19:23:50 +0000916}
917
Paolo Bonzini14e6fe12016-10-31 10:36:08 +0100918void run_on_cpu(CPUState *cpu, run_on_cpu_func func, run_on_cpu_data data)
Marcelo Tosattie82bcec2010-05-04 09:45:22 -0300919{
Sergey Fedorovd148d902016-08-29 09:51:00 +0200920 do_run_on_cpu(cpu, func, data, &qemu_global_mutex);
Chegu Vinod3c022702013-06-24 03:49:41 -0600921}
922
Gu Zheng4c055ab2016-05-12 09:18:13 +0530923static void qemu_kvm_destroy_vcpu(CPUState *cpu)
924{
925 if (kvm_destroy_vcpu(cpu) < 0) {
926 error_report("kvm_destroy_vcpu failed");
927 exit(EXIT_FAILURE);
928 }
929}
930
931static void qemu_tcg_destroy_vcpu(CPUState *cpu)
932{
933}
934
Andreas Färber509a0d72012-05-03 02:18:09 +0200935static void qemu_wait_io_event_common(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +0000936{
Andreas Färber4fdeee72012-05-02 23:10:09 +0200937 if (cpu->stop) {
938 cpu->stop = false;
Andreas Färberf324e762012-05-02 23:26:21 +0200939 cpu->stopped = true;
Dr. David Alan Gilbert96bce682016-01-25 10:08:18 +0000940 qemu_cond_broadcast(&qemu_pause_cond);
Blue Swirl296af7c2010-03-29 19:23:50 +0000941 }
Sergey Fedorova5403c62016-08-02 18:27:36 +0100942 process_queued_cpu_work(cpu);
Andreas Färber216fc9a2012-05-02 17:49:49 +0200943 cpu->thread_kicked = false;
Blue Swirl296af7c2010-03-29 19:23:50 +0000944}
945
KONRAD Fredericd5f8d612015-08-10 17:27:06 +0200946static void qemu_tcg_wait_io_event(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +0000947{
Jan Kiszka16400322011-02-09 16:29:37 +0100948 while (all_cpu_threads_idle()) {
KONRAD Fredericd5f8d612015-08-10 17:27:06 +0200949 qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
Jan Kiszka16400322011-02-09 16:29:37 +0100950 }
Blue Swirl296af7c2010-03-29 19:23:50 +0000951
Paolo Bonzini46daff12011-06-09 13:10:24 +0200952 while (iothread_requesting_mutex) {
953 qemu_cond_wait(&qemu_io_proceeded_cond, &qemu_global_mutex);
954 }
Jan Kiszka6cabe1f2010-06-25 16:56:53 +0200955
Andreas Färberbdc44642013-06-24 23:50:24 +0200956 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +0200957 qemu_wait_io_event_common(cpu);
Jan Kiszka6cabe1f2010-06-25 16:56:53 +0200958 }
Blue Swirl296af7c2010-03-29 19:23:50 +0000959}
960
Andreas Färberfd529e82013-05-26 23:24:55 +0200961static void qemu_kvm_wait_io_event(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +0000962{
Andreas Färbera98ae1d2013-05-26 23:21:08 +0200963 while (cpu_thread_is_idle(cpu)) {
Andreas Färberf5c121b2012-05-03 01:22:49 +0200964 qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
Jan Kiszka16400322011-02-09 16:29:37 +0100965 }
Blue Swirl296af7c2010-03-29 19:23:50 +0000966
Andreas Färber290adf32013-01-17 09:30:27 +0100967 qemu_kvm_eat_signals(cpu);
Andreas Färber509a0d72012-05-03 02:18:09 +0200968 qemu_wait_io_event_common(cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +0000969}
970
Jan Kiszka7e97cd82011-02-07 12:19:12 +0100971static void *qemu_kvm_cpu_thread_fn(void *arg)
Blue Swirl296af7c2010-03-29 19:23:50 +0000972{
Andreas Färber48a106b2013-05-27 02:20:39 +0200973 CPUState *cpu = arg;
Jan Kiszka84b49152011-02-01 22:15:50 +0100974 int r;
Blue Swirl296af7c2010-03-29 19:23:50 +0000975
Paolo Bonziniab28bd22015-07-09 08:55:38 +0200976 rcu_register_thread();
977
Paolo Bonzini2e7f7a32015-06-18 18:47:18 +0200978 qemu_mutex_lock_iothread();
Andreas Färber814e6122012-05-02 17:00:37 +0200979 qemu_thread_get_self(cpu->thread);
Andreas Färber9f09e182012-05-03 06:59:07 +0200980 cpu->thread_id = qemu_get_thread_id();
Pavel Dovgalyuk626cf8f2014-12-08 10:53:17 +0300981 cpu->can_do_io = 1;
Andreas Färber4917cf42013-05-27 05:17:50 +0200982 current_cpu = cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +0000983
Andreas Färber504134d2012-12-17 06:38:45 +0100984 r = kvm_init_vcpu(cpu);
Jan Kiszka84b49152011-02-01 22:15:50 +0100985 if (r < 0) {
986 fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r));
987 exit(1);
988 }
Blue Swirl296af7c2010-03-29 19:23:50 +0000989
Andreas Färber13618e02013-05-26 23:41:00 +0200990 qemu_kvm_init_cpu_signals(cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +0000991
992 /* signal CPU creation */
Andreas Färber61a46212012-05-02 22:49:36 +0200993 cpu->created = true;
Blue Swirl296af7c2010-03-29 19:23:50 +0000994 qemu_cond_signal(&qemu_cpu_cond);
995
Gu Zheng4c055ab2016-05-12 09:18:13 +0530996 do {
Andreas Färbera1fcaa72012-05-02 23:42:26 +0200997 if (cpu_can_run(cpu)) {
Andreas Färber1458c362013-05-26 23:46:55 +0200998 r = kvm_cpu_exec(cpu);
Jan Kiszka83f338f2011-02-07 12:19:17 +0100999 if (r == EXCP_DEBUG) {
Andreas Färber91325042013-05-27 02:07:49 +02001000 cpu_handle_guest_debug(cpu);
Jan Kiszka83f338f2011-02-07 12:19:17 +01001001 }
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001002 }
Andreas Färberfd529e82013-05-26 23:24:55 +02001003 qemu_kvm_wait_io_event(cpu);
Gu Zheng4c055ab2016-05-12 09:18:13 +05301004 } while (!cpu->unplug || cpu_can_run(cpu));
Blue Swirl296af7c2010-03-29 19:23:50 +00001005
Gu Zheng4c055ab2016-05-12 09:18:13 +05301006 qemu_kvm_destroy_vcpu(cpu);
Bharata B Rao2c579042016-05-12 09:18:14 +05301007 cpu->created = false;
1008 qemu_cond_signal(&qemu_cpu_cond);
Gu Zheng4c055ab2016-05-12 09:18:13 +05301009 qemu_mutex_unlock_iothread();
Blue Swirl296af7c2010-03-29 19:23:50 +00001010 return NULL;
1011}
1012
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001013static void *qemu_dummy_cpu_thread_fn(void *arg)
1014{
1015#ifdef _WIN32
1016 fprintf(stderr, "qtest is not supported under Windows\n");
1017 exit(1);
1018#else
Andreas Färber10a90212013-05-27 02:24:35 +02001019 CPUState *cpu = arg;
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001020 sigset_t waitset;
1021 int r;
1022
Paolo Bonziniab28bd22015-07-09 08:55:38 +02001023 rcu_register_thread();
1024
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001025 qemu_mutex_lock_iothread();
Andreas Färber814e6122012-05-02 17:00:37 +02001026 qemu_thread_get_self(cpu->thread);
Andreas Färber9f09e182012-05-03 06:59:07 +02001027 cpu->thread_id = qemu_get_thread_id();
Pavel Dovgalyuk626cf8f2014-12-08 10:53:17 +03001028 cpu->can_do_io = 1;
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001029
1030 sigemptyset(&waitset);
1031 sigaddset(&waitset, SIG_IPI);
1032
1033 /* signal CPU creation */
Andreas Färber61a46212012-05-02 22:49:36 +02001034 cpu->created = true;
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001035 qemu_cond_signal(&qemu_cpu_cond);
1036
Andreas Färber4917cf42013-05-27 05:17:50 +02001037 current_cpu = cpu;
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001038 while (1) {
Andreas Färber4917cf42013-05-27 05:17:50 +02001039 current_cpu = NULL;
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001040 qemu_mutex_unlock_iothread();
1041 do {
1042 int sig;
1043 r = sigwait(&waitset, &sig);
1044 } while (r == -1 && (errno == EAGAIN || errno == EINTR));
1045 if (r == -1) {
1046 perror("sigwait");
1047 exit(1);
1048 }
1049 qemu_mutex_lock_iothread();
Andreas Färber4917cf42013-05-27 05:17:50 +02001050 current_cpu = cpu;
Andreas Färber509a0d72012-05-03 02:18:09 +02001051 qemu_wait_io_event_common(cpu);
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001052 }
1053
1054 return NULL;
1055#endif
1056}
1057
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001058static int64_t tcg_get_icount_limit(void)
1059{
1060 int64_t deadline;
1061
1062 if (replay_mode != REPLAY_MODE_PLAY) {
1063 deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
1064
1065 /* Maintain prior (possibly buggy) behaviour where if no deadline
1066 * was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than
1067 * INT32_MAX nanoseconds ahead, we still use INT32_MAX
1068 * nanoseconds.
1069 */
1070 if ((deadline < 0) || (deadline > INT32_MAX)) {
1071 deadline = INT32_MAX;
1072 }
1073
1074 return qemu_icount_round(deadline);
1075 } else {
1076 return replay_get_instructions();
1077 }
1078}
1079
Alex Bennée12e97002016-10-27 16:10:14 +01001080static void handle_icount_deadline(void)
1081{
1082 if (use_icount) {
1083 int64_t deadline =
1084 qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
1085
1086 if (deadline == 0) {
1087 qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
1088 }
1089 }
1090}
1091
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001092static int tcg_cpu_exec(CPUState *cpu)
1093{
1094 int ret;
1095#ifdef CONFIG_PROFILER
1096 int64_t ti;
1097#endif
1098
1099#ifdef CONFIG_PROFILER
1100 ti = profile_getclock();
1101#endif
1102 if (use_icount) {
1103 int64_t count;
1104 int decr;
1105 timers_state.qemu_icount -= (cpu->icount_decr.u16.low
1106 + cpu->icount_extra);
1107 cpu->icount_decr.u16.low = 0;
1108 cpu->icount_extra = 0;
1109 count = tcg_get_icount_limit();
1110 timers_state.qemu_icount += count;
1111 decr = (count > 0xffff) ? 0xffff : count;
1112 count -= decr;
1113 cpu->icount_decr.u16.low = decr;
1114 cpu->icount_extra = count;
1115 }
1116 cpu_exec_start(cpu);
1117 ret = cpu_exec(cpu);
1118 cpu_exec_end(cpu);
1119#ifdef CONFIG_PROFILER
1120 tcg_time += profile_getclock() - ti;
1121#endif
1122 if (use_icount) {
1123 /* Fold pending instructions back into the
1124 instruction counter, and clear the interrupt flag. */
1125 timers_state.qemu_icount -= (cpu->icount_decr.u16.low
1126 + cpu->icount_extra);
1127 cpu->icount_decr.u32 = 0;
1128 cpu->icount_extra = 0;
1129 replay_account_executed_instructions();
1130 }
1131 return ret;
1132}
1133
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001134/* Destroy any remaining vCPUs which have been unplugged and have
1135 * finished running
1136 */
1137static void deal_with_unplugged_cpus(void)
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001138{
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001139 CPUState *cpu;
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001140
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001141 CPU_FOREACH(cpu) {
1142 if (cpu->unplug && !cpu_can_run(cpu)) {
1143 qemu_tcg_destroy_vcpu(cpu);
1144 cpu->created = false;
1145 qemu_cond_signal(&qemu_cpu_cond);
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001146 break;
1147 }
1148 }
Alex Bennée1be7fcb2016-10-27 16:10:08 +01001149}
Jan Kiszkabdb7ca62011-09-26 09:40:39 +02001150
Jan Kiszka7e97cd82011-02-07 12:19:12 +01001151static void *qemu_tcg_cpu_thread_fn(void *arg)
Blue Swirl296af7c2010-03-29 19:23:50 +00001152{
Andreas Färberc3586ba2012-05-03 01:41:24 +02001153 CPUState *cpu = arg;
Blue Swirl296af7c2010-03-29 19:23:50 +00001154
Paolo Bonziniab28bd22015-07-09 08:55:38 +02001155 rcu_register_thread();
1156
Paolo Bonzini2e7f7a32015-06-18 18:47:18 +02001157 qemu_mutex_lock_iothread();
Andreas Färber814e6122012-05-02 17:00:37 +02001158 qemu_thread_get_self(cpu->thread);
Blue Swirl296af7c2010-03-29 19:23:50 +00001159
Andreas Färber38fcbd32013-07-07 19:50:23 +02001160 CPU_FOREACH(cpu) {
1161 cpu->thread_id = qemu_get_thread_id();
1162 cpu->created = true;
Pavel Dovgalyuk626cf8f2014-12-08 10:53:17 +03001163 cpu->can_do_io = 1;
Andreas Färber38fcbd32013-07-07 19:50:23 +02001164 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001165 qemu_cond_signal(&qemu_cpu_cond);
1166
Jan Kiszkafa7d1862011-08-22 18:35:25 +02001167 /* wait for initial kick-off after machine start */
Emilio G. Cotac28e3992015-04-27 12:45:28 -04001168 while (first_cpu->stopped) {
KONRAD Fredericd5f8d612015-08-10 17:27:06 +02001169 qemu_cond_wait(first_cpu->halt_cond, &qemu_global_mutex);
Jan Kiszka8e564b42012-02-17 18:31:15 +01001170
1171 /* process any pending work */
Andreas Färberbdc44642013-06-24 23:50:24 +02001172 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +02001173 qemu_wait_io_event_common(cpu);
Jan Kiszka8e564b42012-02-17 18:31:15 +01001174 }
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001175 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001176
Paolo Bonzini21618b32015-02-27 20:01:03 +01001177 /* process any pending work */
Paolo Bonziniaed807c2015-08-18 06:43:15 -07001178 atomic_mb_set(&exit_request, 1);
Paolo Bonzini21618b32015-02-27 20:01:03 +01001179
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001180 cpu = first_cpu;
1181
Blue Swirl296af7c2010-03-29 19:23:50 +00001182 while (1) {
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001183 /* Account partial waits to QEMU_CLOCK_VIRTUAL. */
1184 qemu_account_warp_timer();
1185
1186 if (!cpu) {
1187 cpu = first_cpu;
1188 }
1189
1190 for (; cpu != NULL && !exit_request; cpu = CPU_NEXT(cpu)) {
1191
1192 qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
1193 (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);
1194
1195 if (cpu_can_run(cpu)) {
1196 int r;
1197 r = tcg_cpu_exec(cpu);
1198 if (r == EXCP_DEBUG) {
1199 cpu_handle_guest_debug(cpu);
1200 break;
1201 }
1202 } else if (cpu->stop || cpu->stopped) {
1203 if (cpu->unplug) {
1204 cpu = CPU_NEXT(cpu);
1205 }
1206 break;
1207 }
1208
1209 } /* for cpu.. */
1210
1211 /* Pairs with smp_wmb in qemu_cpu_kick. */
1212 atomic_mb_set(&exit_request, 0);
Alex Blighac70aaf2013-08-21 16:02:57 +01001213
Alex Bennée12e97002016-10-27 16:10:14 +01001214 handle_icount_deadline();
Alex Blighac70aaf2013-08-21 16:02:57 +01001215
KONRAD Fredericd5f8d612015-08-10 17:27:06 +02001216 qemu_tcg_wait_io_event(QTAILQ_FIRST(&cpus));
Alex Bennéec93bbbe2016-10-27 16:10:09 +01001217 deal_with_unplugged_cpus();
Blue Swirl296af7c2010-03-29 19:23:50 +00001218 }
1219
1220 return NULL;
1221}
1222
Andreas Färber2ff09a42012-05-03 00:23:30 +02001223static void qemu_cpu_kick_thread(CPUState *cpu)
Paolo Bonzinicc015e92011-03-12 17:44:08 +01001224{
1225#ifndef _WIN32
1226 int err;
1227
Paolo Bonzinie0c38212015-08-26 00:19:19 +02001228 if (cpu->thread_kicked) {
1229 return;
Paolo Bonzini9102ded2015-08-18 06:52:09 -07001230 }
Paolo Bonzinie0c38212015-08-26 00:19:19 +02001231 cpu->thread_kicked = true;
Andreas Färber814e6122012-05-02 17:00:37 +02001232 err = pthread_kill(cpu->thread->thread, SIG_IPI);
Paolo Bonzinicc015e92011-03-12 17:44:08 +01001233 if (err) {
1234 fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
1235 exit(1);
1236 }
1237#else /* _WIN32 */
Paolo Bonzinie0c38212015-08-26 00:19:19 +02001238 abort();
Paolo Bonzinicc015e92011-03-12 17:44:08 +01001239#endif
1240}
1241
Paolo Bonzinie0c38212015-08-26 00:19:19 +02001242static void qemu_cpu_kick_no_halt(void)
1243{
1244 CPUState *cpu;
1245 /* Ensure whatever caused the exit has reached the CPU threads before
1246 * writing exit_request.
1247 */
1248 atomic_mb_set(&exit_request, 1);
1249 cpu = atomic_mb_read(&tcg_current_cpu);
1250 if (cpu) {
1251 cpu_exit(cpu);
1252 }
1253}
1254
Andreas Färberc08d7422012-05-03 04:34:15 +02001255void qemu_cpu_kick(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +00001256{
Andreas Färberf5c121b2012-05-03 01:22:49 +02001257 qemu_cond_broadcast(cpu->halt_cond);
Paolo Bonzinie0c38212015-08-26 00:19:19 +02001258 if (tcg_enabled()) {
1259 qemu_cpu_kick_no_halt();
1260 } else {
1261 qemu_cpu_kick_thread(cpu);
1262 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001263}
1264
Jan Kiszka46d62fa2011-02-01 22:15:59 +01001265void qemu_cpu_kick_self(void)
1266{
Andreas Färber4917cf42013-05-27 05:17:50 +02001267 assert(current_cpu);
Paolo Bonzini9102ded2015-08-18 06:52:09 -07001268 qemu_cpu_kick_thread(current_cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +00001269}
1270
Andreas Färber60e82572012-05-02 22:23:49 +02001271bool qemu_cpu_is_self(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +00001272{
Andreas Färber814e6122012-05-02 17:00:37 +02001273 return qemu_thread_is_self(cpu->thread);
Blue Swirl296af7c2010-03-29 19:23:50 +00001274}
1275
Paolo Bonzini79e2b9a2015-01-21 12:09:14 +01001276bool qemu_in_vcpu_thread(void)
Juan Quintelaaa723c22012-09-18 16:30:11 +02001277{
Andreas Färber4917cf42013-05-27 05:17:50 +02001278 return current_cpu && qemu_cpu_is_self(current_cpu);
Juan Quintelaaa723c22012-09-18 16:30:11 +02001279}
1280
Paolo Bonziniafbe7052015-06-18 18:47:19 +02001281static __thread bool iothread_locked = false;
1282
1283bool qemu_mutex_iothread_locked(void)
1284{
1285 return iothread_locked;
1286}
1287
Blue Swirl296af7c2010-03-29 19:23:50 +00001288void qemu_mutex_lock_iothread(void)
1289{
Paolo Bonzini21618b32015-02-27 20:01:03 +01001290 atomic_inc(&iothread_requesting_mutex);
Paolo Bonzini2e7f7a32015-06-18 18:47:18 +02001291 /* In the simple case there is no need to bump the VCPU thread out of
1292 * TCG code execution.
1293 */
1294 if (!tcg_enabled() || qemu_in_vcpu_thread() ||
Aníbal Limón46036b22015-09-03 15:48:33 -05001295 !first_cpu || !first_cpu->created) {
Blue Swirl296af7c2010-03-29 19:23:50 +00001296 qemu_mutex_lock(&qemu_global_mutex);
Paolo Bonzini21618b32015-02-27 20:01:03 +01001297 atomic_dec(&iothread_requesting_mutex);
Marcelo Tosatti1a28cac2010-05-04 09:45:20 -03001298 } else {
Marcelo Tosatti1a28cac2010-05-04 09:45:20 -03001299 if (qemu_mutex_trylock(&qemu_global_mutex)) {
Paolo Bonzinie0c38212015-08-26 00:19:19 +02001300 qemu_cpu_kick_no_halt();
Marcelo Tosatti1a28cac2010-05-04 09:45:20 -03001301 qemu_mutex_lock(&qemu_global_mutex);
1302 }
Paolo Bonzini6b498092015-02-27 19:58:23 +01001303 atomic_dec(&iothread_requesting_mutex);
Paolo Bonzini46daff12011-06-09 13:10:24 +02001304 qemu_cond_broadcast(&qemu_io_proceeded_cond);
Marcelo Tosatti1a28cac2010-05-04 09:45:20 -03001305 }
Paolo Bonziniafbe7052015-06-18 18:47:19 +02001306 iothread_locked = true;
Blue Swirl296af7c2010-03-29 19:23:50 +00001307}
1308
1309void qemu_mutex_unlock_iothread(void)
1310{
Paolo Bonziniafbe7052015-06-18 18:47:19 +02001311 iothread_locked = false;
Blue Swirl296af7c2010-03-29 19:23:50 +00001312 qemu_mutex_unlock(&qemu_global_mutex);
1313}
1314
Alex Bennéee8faee02016-10-27 16:09:58 +01001315static bool all_vcpus_paused(void)
Blue Swirl296af7c2010-03-29 19:23:50 +00001316{
Andreas Färberbdc44642013-06-24 23:50:24 +02001317 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +00001318
Andreas Färberbdc44642013-06-24 23:50:24 +02001319 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +02001320 if (!cpu->stopped) {
Alex Bennéee8faee02016-10-27 16:09:58 +01001321 return false;
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001322 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001323 }
1324
Alex Bennéee8faee02016-10-27 16:09:58 +01001325 return true;
Blue Swirl296af7c2010-03-29 19:23:50 +00001326}
1327
1328void pause_all_vcpus(void)
1329{
Andreas Färberbdc44642013-06-24 23:50:24 +02001330 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +00001331
Alex Bligh40daca52013-08-21 16:03:02 +01001332 qemu_clock_enable(QEMU_CLOCK_VIRTUAL, false);
Andreas Färberbdc44642013-06-24 23:50:24 +02001333 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +02001334 cpu->stop = true;
1335 qemu_cpu_kick(cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +00001336 }
1337
Juan Quintelaaa723c22012-09-18 16:30:11 +02001338 if (qemu_in_vcpu_thread()) {
Jan Kiszkad798e972012-02-17 18:31:16 +01001339 cpu_stop_current();
1340 if (!kvm_enabled()) {
Andreas Färberbdc44642013-06-24 23:50:24 +02001341 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +02001342 cpu->stop = false;
1343 cpu->stopped = true;
Jan Kiszkad798e972012-02-17 18:31:16 +01001344 }
1345 return;
1346 }
1347 }
1348
Blue Swirl296af7c2010-03-29 19:23:50 +00001349 while (!all_vcpus_paused()) {
Paolo Bonzinibe7d6c52011-03-12 17:44:02 +01001350 qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
Andreas Färberbdc44642013-06-24 23:50:24 +02001351 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +02001352 qemu_cpu_kick(cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +00001353 }
1354 }
1355}
1356
Igor Mammedov29936832013-04-23 10:29:37 +02001357void cpu_resume(CPUState *cpu)
1358{
1359 cpu->stop = false;
1360 cpu->stopped = false;
1361 qemu_cpu_kick(cpu);
1362}
1363
Blue Swirl296af7c2010-03-29 19:23:50 +00001364void resume_all_vcpus(void)
1365{
Andreas Färberbdc44642013-06-24 23:50:24 +02001366 CPUState *cpu;
Blue Swirl296af7c2010-03-29 19:23:50 +00001367
Alex Bligh40daca52013-08-21 16:03:02 +01001368 qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
Andreas Färberbdc44642013-06-24 23:50:24 +02001369 CPU_FOREACH(cpu) {
Andreas Färber182735e2013-05-29 22:29:20 +02001370 cpu_resume(cpu);
Blue Swirl296af7c2010-03-29 19:23:50 +00001371 }
1372}
1373
Gu Zheng4c055ab2016-05-12 09:18:13 +05301374void cpu_remove(CPUState *cpu)
1375{
1376 cpu->stop = true;
1377 cpu->unplug = true;
1378 qemu_cpu_kick(cpu);
1379}
1380
Bharata B Rao2c579042016-05-12 09:18:14 +05301381void cpu_remove_sync(CPUState *cpu)
1382{
1383 cpu_remove(cpu);
1384 while (cpu->created) {
1385 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1386 }
1387}
1388
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001389/* For temporary buffers for forming a name */
1390#define VCPU_THREAD_NAME_SIZE 16
1391
Andreas Färbere5ab30a2012-05-03 01:50:44 +02001392static void qemu_tcg_init_vcpu(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +00001393{
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001394 char thread_name[VCPU_THREAD_NAME_SIZE];
KONRAD Fredericd5f8d612015-08-10 17:27:06 +02001395 static QemuCond *tcg_halt_cond;
1396 static QemuThread *tcg_cpu_thread;
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001397
Blue Swirl296af7c2010-03-29 19:23:50 +00001398 /* share a single thread for all cpus with TCG */
1399 if (!tcg_cpu_thread) {
Andreas Färber814e6122012-05-02 17:00:37 +02001400 cpu->thread = g_malloc0(sizeof(QemuThread));
Andreas Färberf5c121b2012-05-03 01:22:49 +02001401 cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1402 qemu_cond_init(cpu->halt_cond);
1403 tcg_halt_cond = cpu->halt_cond;
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001404 snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/TCG",
1405 cpu->cpu_index);
1406 qemu_thread_create(cpu->thread, thread_name, qemu_tcg_cpu_thread_fn,
1407 cpu, QEMU_THREAD_JOINABLE);
Paolo Bonzini1ecf47b2011-12-13 13:43:52 +01001408#ifdef _WIN32
Andreas Färber814e6122012-05-02 17:00:37 +02001409 cpu->hThread = qemu_thread_get_handle(cpu->thread);
Paolo Bonzini1ecf47b2011-12-13 13:43:52 +01001410#endif
Andreas Färber61a46212012-05-02 22:49:36 +02001411 while (!cpu->created) {
Paolo Bonzini18a85722011-03-12 17:44:03 +01001412 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001413 }
Andreas Färber814e6122012-05-02 17:00:37 +02001414 tcg_cpu_thread = cpu->thread;
Blue Swirl296af7c2010-03-29 19:23:50 +00001415 } else {
Andreas Färber814e6122012-05-02 17:00:37 +02001416 cpu->thread = tcg_cpu_thread;
Andreas Färberf5c121b2012-05-03 01:22:49 +02001417 cpu->halt_cond = tcg_halt_cond;
Blue Swirl296af7c2010-03-29 19:23:50 +00001418 }
1419}
1420
Andreas Färber48a106b2013-05-27 02:20:39 +02001421static void qemu_kvm_start_vcpu(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +00001422{
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001423 char thread_name[VCPU_THREAD_NAME_SIZE];
1424
Andreas Färber814e6122012-05-02 17:00:37 +02001425 cpu->thread = g_malloc0(sizeof(QemuThread));
Andreas Färberf5c121b2012-05-03 01:22:49 +02001426 cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1427 qemu_cond_init(cpu->halt_cond);
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001428 snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/KVM",
1429 cpu->cpu_index);
1430 qemu_thread_create(cpu->thread, thread_name, qemu_kvm_cpu_thread_fn,
1431 cpu, QEMU_THREAD_JOINABLE);
Andreas Färber61a46212012-05-02 22:49:36 +02001432 while (!cpu->created) {
Paolo Bonzini18a85722011-03-12 17:44:03 +01001433 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001434 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001435}
1436
Andreas Färber10a90212013-05-27 02:24:35 +02001437static void qemu_dummy_start_vcpu(CPUState *cpu)
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001438{
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001439 char thread_name[VCPU_THREAD_NAME_SIZE];
1440
Andreas Färber814e6122012-05-02 17:00:37 +02001441 cpu->thread = g_malloc0(sizeof(QemuThread));
Andreas Färberf5c121b2012-05-03 01:22:49 +02001442 cpu->halt_cond = g_malloc0(sizeof(QemuCond));
1443 qemu_cond_init(cpu->halt_cond);
Dr. David Alan Gilbert49001162014-01-30 10:20:32 +00001444 snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/DUMMY",
1445 cpu->cpu_index);
1446 qemu_thread_create(cpu->thread, thread_name, qemu_dummy_cpu_thread_fn, cpu,
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001447 QEMU_THREAD_JOINABLE);
Andreas Färber61a46212012-05-02 22:49:36 +02001448 while (!cpu->created) {
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001449 qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
1450 }
1451}
1452
Andreas Färberc643bed2013-05-27 03:23:24 +02001453void qemu_init_vcpu(CPUState *cpu)
Blue Swirl296af7c2010-03-29 19:23:50 +00001454{
Andreas Färberce3960e2012-12-17 03:27:07 +01001455 cpu->nr_cores = smp_cores;
1456 cpu->nr_threads = smp_threads;
Andreas Färberf324e762012-05-02 23:26:21 +02001457 cpu->stopped = true;
Peter Maydell56943e82016-01-21 14:15:04 +00001458
1459 if (!cpu->as) {
1460 /* If the target cpu hasn't set up any address spaces itself,
1461 * give it the default one.
1462 */
Peter Crosthwaite6731d862016-01-21 14:15:06 +00001463 AddressSpace *as = address_space_init_shareable(cpu->memory,
1464 "cpu-memory");
Peter Maydell12ebc9a2016-01-21 14:15:04 +00001465 cpu->num_ases = 1;
Peter Crosthwaite6731d862016-01-21 14:15:06 +00001466 cpu_address_space_init(cpu, as, 0);
Peter Maydell56943e82016-01-21 14:15:04 +00001467 }
1468
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001469 if (kvm_enabled()) {
Andreas Färber48a106b2013-05-27 02:20:39 +02001470 qemu_kvm_start_vcpu(cpu);
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001471 } else if (tcg_enabled()) {
Andreas Färbere5ab30a2012-05-03 01:50:44 +02001472 qemu_tcg_init_vcpu(cpu);
Anthony Liguoric7f0f3b2012-03-28 15:42:02 +02001473 } else {
Andreas Färber10a90212013-05-27 02:24:35 +02001474 qemu_dummy_start_vcpu(cpu);
Jan Kiszka0ab07c62011-02-07 12:19:14 +01001475 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001476}
1477
Jan Kiszkab4a3d962011-02-01 22:15:43 +01001478void cpu_stop_current(void)
Blue Swirl296af7c2010-03-29 19:23:50 +00001479{
Andreas Färber4917cf42013-05-27 05:17:50 +02001480 if (current_cpu) {
1481 current_cpu->stop = false;
1482 current_cpu->stopped = true;
1483 cpu_exit(current_cpu);
Dr. David Alan Gilbert96bce682016-01-25 10:08:18 +00001484 qemu_cond_broadcast(&qemu_pause_cond);
Jan Kiszkab4a3d962011-02-01 22:15:43 +01001485 }
Blue Swirl296af7c2010-03-29 19:23:50 +00001486}
1487
Kevin Wolf56983462013-07-05 13:49:54 +02001488int vm_stop(RunState state)
Blue Swirl296af7c2010-03-29 19:23:50 +00001489{
Juan Quintelaaa723c22012-09-18 16:30:11 +02001490 if (qemu_in_vcpu_thread()) {
Paolo Bonzini74892d22014-06-05 14:53:58 +02001491 qemu_system_vmstop_request_prepare();
Luiz Capitulino1dfb4dd2011-07-29 14:26:33 -03001492 qemu_system_vmstop_request(state);
Blue Swirl296af7c2010-03-29 19:23:50 +00001493 /*
1494 * FIXME: should not return to device code in case
1495 * vm_stop() has been requested.
1496 */
Jan Kiszkab4a3d962011-02-01 22:15:43 +01001497 cpu_stop_current();
Kevin Wolf56983462013-07-05 13:49:54 +02001498 return 0;
Blue Swirl296af7c2010-03-29 19:23:50 +00001499 }
Kevin Wolf56983462013-07-05 13:49:54 +02001500
1501 return do_vm_stop(state);
Blue Swirl296af7c2010-03-29 19:23:50 +00001502}
1503
Luiz Capitulino8a9236f2011-10-14 11:18:09 -03001504/* does a state transition even if the VM is already stopped,
1505 current state is forgotten forever */
Kevin Wolf56983462013-07-05 13:49:54 +02001506int vm_stop_force_state(RunState state)
Luiz Capitulino8a9236f2011-10-14 11:18:09 -03001507{
1508 if (runstate_is_running()) {
Kevin Wolf56983462013-07-05 13:49:54 +02001509 return vm_stop(state);
Luiz Capitulino8a9236f2011-10-14 11:18:09 -03001510 } else {
1511 runstate_set(state);
Wen Congyangb2780d32015-11-20 17:34:38 +08001512
1513 bdrv_drain_all();
Kevin Wolf594a45c2013-07-18 14:52:19 +02001514 /* Make sure to return an error if the flush in a previous vm_stop()
1515 * failed. */
John Snow22af08e2016-09-22 21:45:51 -04001516 return bdrv_flush_all();
Luiz Capitulino8a9236f2011-10-14 11:18:09 -03001517 }
1518}
1519
Stefan Weil9a78eea2010-10-22 23:03:33 +02001520void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
Blue Swirl262353c2010-05-04 19:55:35 +00001521{
1522 /* XXX: implement xxx_cpu_list for targets that still miss it */
Peter Maydelle916cbf2012-09-05 17:41:08 -03001523#if defined(cpu_list)
1524 cpu_list(f, cpu_fprintf);
Blue Swirl262353c2010-05-04 19:55:35 +00001525#endif
1526}
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03001527
1528CpuInfoList *qmp_query_cpus(Error **errp)
1529{
1530 CpuInfoList *head = NULL, *cur_item = NULL;
Andreas Färber182735e2013-05-29 22:29:20 +02001531 CPUState *cpu;
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03001532
Andreas Färberbdc44642013-06-24 23:50:24 +02001533 CPU_FOREACH(cpu) {
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03001534 CpuInfoList *info;
Andreas Färber182735e2013-05-29 22:29:20 +02001535#if defined(TARGET_I386)
1536 X86CPU *x86_cpu = X86_CPU(cpu);
1537 CPUX86State *env = &x86_cpu->env;
1538#elif defined(TARGET_PPC)
1539 PowerPCCPU *ppc_cpu = POWERPC_CPU(cpu);
1540 CPUPPCState *env = &ppc_cpu->env;
1541#elif defined(TARGET_SPARC)
1542 SPARCCPU *sparc_cpu = SPARC_CPU(cpu);
1543 CPUSPARCState *env = &sparc_cpu->env;
1544#elif defined(TARGET_MIPS)
1545 MIPSCPU *mips_cpu = MIPS_CPU(cpu);
1546 CPUMIPSState *env = &mips_cpu->env;
Bastian Koppelmann48e06fe2014-09-01 12:59:46 +01001547#elif defined(TARGET_TRICORE)
1548 TriCoreCPU *tricore_cpu = TRICORE_CPU(cpu);
1549 CPUTriCoreState *env = &tricore_cpu->env;
Andreas Färber182735e2013-05-29 22:29:20 +02001550#endif
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03001551
Andreas Färbercb446ec2013-05-01 14:24:52 +02001552 cpu_synchronize_state(cpu);
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03001553
1554 info = g_malloc0(sizeof(*info));
1555 info->value = g_malloc0(sizeof(*info->value));
Andreas Färber55e5c282012-12-17 06:18:02 +01001556 info->value->CPU = cpu->cpu_index;
Andreas Färber182735e2013-05-29 22:29:20 +02001557 info->value->current = (cpu == first_cpu);
Andreas Färber259186a2013-01-17 18:51:17 +01001558 info->value->halted = cpu->halted;
Eduardo Habkost58f88d42015-05-08 16:04:22 -03001559 info->value->qom_path = object_get_canonical_path(OBJECT(cpu));
Andreas Färber9f09e182012-05-03 06:59:07 +02001560 info->value->thread_id = cpu->thread_id;
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03001561#if defined(TARGET_I386)
Eric Blake86f4b682015-11-18 01:52:59 -07001562 info->value->arch = CPU_INFO_ARCH_X86;
Eric Blake544a3732016-02-17 23:48:27 -07001563 info->value->u.x86.pc = env->eip + env->segs[R_CS].base;
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03001564#elif defined(TARGET_PPC)
Eric Blake86f4b682015-11-18 01:52:59 -07001565 info->value->arch = CPU_INFO_ARCH_PPC;
Eric Blake544a3732016-02-17 23:48:27 -07001566 info->value->u.ppc.nip = env->nip;
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03001567#elif defined(TARGET_SPARC)
Eric Blake86f4b682015-11-18 01:52:59 -07001568 info->value->arch = CPU_INFO_ARCH_SPARC;
Eric Blake544a3732016-02-17 23:48:27 -07001569 info->value->u.q_sparc.pc = env->pc;
1570 info->value->u.q_sparc.npc = env->npc;
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03001571#elif defined(TARGET_MIPS)
Eric Blake86f4b682015-11-18 01:52:59 -07001572 info->value->arch = CPU_INFO_ARCH_MIPS;
Eric Blake544a3732016-02-17 23:48:27 -07001573 info->value->u.q_mips.PC = env->active_tc.PC;
Bastian Koppelmann48e06fe2014-09-01 12:59:46 +01001574#elif defined(TARGET_TRICORE)
Eric Blake86f4b682015-11-18 01:52:59 -07001575 info->value->arch = CPU_INFO_ARCH_TRICORE;
Eric Blake544a3732016-02-17 23:48:27 -07001576 info->value->u.tricore.PC = env->PC;
Eric Blake86f4b682015-11-18 01:52:59 -07001577#else
1578 info->value->arch = CPU_INFO_ARCH_OTHER;
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03001579#endif
1580
1581 /* XXX: waiting for the qapi to support GSList */
1582 if (!cur_item) {
1583 head = cur_item = info;
1584 } else {
1585 cur_item->next = info;
1586 cur_item = info;
1587 }
1588 }
1589
1590 return head;
1591}
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02001592
1593void qmp_memsave(int64_t addr, int64_t size, const char *filename,
1594 bool has_cpu, int64_t cpu_index, Error **errp)
1595{
1596 FILE *f;
1597 uint32_t l;
Andreas Färber55e5c282012-12-17 06:18:02 +01001598 CPUState *cpu;
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02001599 uint8_t buf[1024];
Borislav Petkov0dc9daf2015-02-08 13:14:38 +01001600 int64_t orig_addr = addr, orig_size = size;
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02001601
1602 if (!has_cpu) {
1603 cpu_index = 0;
1604 }
1605
Andreas Färber151d1322013-02-15 15:41:49 +01001606 cpu = qemu_get_cpu(cpu_index);
1607 if (cpu == NULL) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01001608 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
1609 "a CPU number");
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02001610 return;
1611 }
1612
1613 f = fopen(filename, "wb");
1614 if (!f) {
Luiz Capitulino618da852013-06-07 14:35:06 -04001615 error_setg_file_open(errp, errno, filename);
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02001616 return;
1617 }
1618
1619 while (size != 0) {
1620 l = sizeof(buf);
1621 if (l > size)
1622 l = size;
Aneesh Kumar K.V2f4d0f52013-10-01 21:49:30 +05301623 if (cpu_memory_rw_debug(cpu, addr, buf, l, 0) != 0) {
Borislav Petkov0dc9daf2015-02-08 13:14:38 +01001624 error_setg(errp, "Invalid addr 0x%016" PRIx64 "/size %" PRId64
1625 " specified", orig_addr, orig_size);
Aneesh Kumar K.V2f4d0f52013-10-01 21:49:30 +05301626 goto exit;
1627 }
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02001628 if (fwrite(buf, 1, l, f) != l) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01001629 error_setg(errp, QERR_IO_ERROR);
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -02001630 goto exit;
1631 }
1632 addr += l;
1633 size -= l;
1634 }
1635
1636exit:
1637 fclose(f);
1638}
Luiz Capitulino6d3962b2011-11-22 17:26:46 -02001639
1640void qmp_pmemsave(int64_t addr, int64_t size, const char *filename,
1641 Error **errp)
1642{
1643 FILE *f;
1644 uint32_t l;
1645 uint8_t buf[1024];
1646
1647 f = fopen(filename, "wb");
1648 if (!f) {
Luiz Capitulino618da852013-06-07 14:35:06 -04001649 error_setg_file_open(errp, errno, filename);
Luiz Capitulino6d3962b2011-11-22 17:26:46 -02001650 return;
1651 }
1652
1653 while (size != 0) {
1654 l = sizeof(buf);
1655 if (l > size)
1656 l = size;
Stefan Weileb6282f2014-04-07 20:28:23 +02001657 cpu_physical_memory_read(addr, buf, l);
Luiz Capitulino6d3962b2011-11-22 17:26:46 -02001658 if (fwrite(buf, 1, l, f) != l) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01001659 error_setg(errp, QERR_IO_ERROR);
Luiz Capitulino6d3962b2011-11-22 17:26:46 -02001660 goto exit;
1661 }
1662 addr += l;
1663 size -= l;
1664 }
1665
1666exit:
1667 fclose(f);
1668}
Luiz Capitulinoab49ab52011-11-23 12:55:53 -02001669
1670void qmp_inject_nmi(Error **errp)
1671{
Alexey Kardashevskiy9cb805f2014-08-20 22:16:33 +10001672 nmi_monitor_handle(monitor_get_cpu_index(), errp);
Luiz Capitulinoab49ab52011-11-23 12:55:53 -02001673}
Sebastian Tanase27498be2014-07-25 11:56:33 +02001674
1675void dump_drift_info(FILE *f, fprintf_function cpu_fprintf)
1676{
1677 if (!use_icount) {
1678 return;
1679 }
1680
1681 cpu_fprintf(f, "Host - Guest clock %"PRIi64" ms\n",
1682 (cpu_get_clock() - cpu_get_icount())/SCALE_MS);
1683 if (icount_align_option) {
1684 cpu_fprintf(f, "Max guest delay %"PRIi64" ms\n", -max_delay/SCALE_MS);
1685 cpu_fprintf(f, "Max guest advance %"PRIi64" ms\n", max_advance/SCALE_MS);
1686 } else {
1687 cpu_fprintf(f, "Max guest delay NA\n");
1688 cpu_fprintf(f, "Max guest advance NA\n");
1689 }
1690}