2010-03-29 21:23:50 +02:00
|
|
|
/*
|
|
|
|
* QEMU System Emulator
|
|
|
|
*
|
|
|
|
* Copyright (c) 2003-2008 Fabrice Bellard
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
2016-01-26 19:16:56 +01:00
|
|
|
#include "qemu/osdep.h"
|
2017-02-23 19:29:08 +01:00
|
|
|
#include "qemu/config-file.h"
|
2016-03-15 16:58:45 +01:00
|
|
|
#include "cpu.h"
|
2012-12-17 18:19:49 +01:00
|
|
|
#include "monitor/monitor.h"
|
2018-02-01 12:18:31 +01:00
|
|
|
#include "qapi/error.h"
|
2018-02-27 00:13:27 +01:00
|
|
|
#include "qapi/qapi-commands-misc.h"
|
2018-02-11 10:36:01 +01:00
|
|
|
#include "qapi/qapi-events-run-state.h"
|
2014-06-18 08:43:36 +02:00
|
|
|
#include "qapi/qmp/qerror.h"
|
2015-03-17 18:29:20 +01:00
|
|
|
#include "qemu/error-report.h"
|
2012-12-17 18:20:04 +01:00
|
|
|
#include "sysemu/sysemu.h"
|
2016-03-16 19:54:32 +01:00
|
|
|
#include "sysemu/block-backend.h"
|
2012-12-17 18:19:49 +01:00
|
|
|
#include "exec/gdbstub.h"
|
2012-12-17 18:20:04 +01:00
|
|
|
#include "sysemu/dma.h"
|
2017-01-10 11:59:55 +01:00
|
|
|
#include "sysemu/hw_accel.h"
|
2012-12-17 18:20:04 +01:00
|
|
|
#include "sysemu/kvm.h"
|
2017-01-10 11:59:57 +01:00
|
|
|
#include "sysemu/hax.h"
|
i386: hvf: add code base from Google's QEMU repository
This file begins tracking the files that will be the code base for HVF
support in QEMU. This code base is part of Google's QEMU version of
their Android emulator, and can be found at
https://android.googlesource.com/platform/external/qemu/+/emu-master-dev
This code is based on Veertu Inc's vdhh (Veertu Desktop Hosted
Hypervisor), found at https://github.com/veertuinc/vdhh. Everything is
appropriately licensed under GPL v2-or-later, except for the code inside
x86_task.c and x86_task.h, which, deriving from KVM (the Linux kernel),
is licensed GPL v2-only.
This code base already implements a very great deal of functionality,
although Google's version removed from Vertuu's the support for APIC
page and hyperv-related stuff. According to the Android Emulator Release
Notes, Revision 26.1.3 (August 2017), "Hypervisor.framework is now
enabled by default on macOS for 32-bit x86 images to improve performance
and macOS compatibility", although we better use with caution for, as the
same Revision warns us, "If you experience issues with it specifically,
please file a bug report...". The code hasn't seen much update in the
last 5 months, so I think that we can further develop the code with
occasional visiting Google's repository to see if there has been any
update.
On top of Google's code, the following changes were made:
- add code to the configure script to support the --enable-hvf argument.
If the OS is Darwin, it checks for presence of HVF in the system. The
patch also adds strings related to HVF in the file qemu-options.hx.
QEMU will only support the modern syntax style '-M accel=hvf' no enable
hvf; the legacy '-enable-hvf' will not be supported.
- fix styling issues
- add glue code to cpus.c
- move HVFX86EmulatorState field to CPUX86State, changing the
the emulation functions to have a parameter with signature 'CPUX86State *'
instead of 'CPUState *' so we don't have to get the 'env'.
Signed-off-by: Sergio Andres Gomez Del Real <Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-2-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-3-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-5-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-6-Sergio.G.DelReal@gmail.com>
Message-Id: <20170905035457.3753-7-Sergio.G.DelReal@gmail.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-09-13 11:05:09 +02:00
|
|
|
#include "sysemu/hvf.h"
|
2018-01-22 22:07:49 +01:00
|
|
|
#include "sysemu/whpx.h"
|
2016-03-15 13:18:37 +01:00
|
|
|
#include "exec/exec-all.h"
|
2010-03-29 21:23:50 +02:00
|
|
|
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/thread.h"
|
2012-12-17 18:20:04 +01:00
|
|
|
#include "sysemu/cpus.h"
|
|
|
|
#include "sysemu/qtest.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/main-loop.h"
|
2018-02-01 12:18:46 +01:00
|
|
|
#include "qemu/option.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/bitmap.h"
|
2013-09-25 08:20:58 +02:00
|
|
|
#include "qemu/seqlock.h"
|
2017-02-23 19:29:08 +01:00
|
|
|
#include "tcg.h"
|
2014-08-20 14:16:33 +02:00
|
|
|
#include "hw/nmi.h"
|
2015-09-17 18:24:05 +02:00
|
|
|
#include "sysemu/replay.h"
|
2017-05-10 13:29:55 +02:00
|
|
|
#include "hw/boards.h"
|
2011-06-23 10:15:55 +02:00
|
|
|
|
2011-02-01 22:15:58 +01:00
|
|
|
#ifdef CONFIG_LINUX
|
|
|
|
|
|
|
|
#include <sys/prctl.h>
|
|
|
|
|
2010-10-11 20:31:21 +02:00
|
|
|
#ifndef PR_MCE_KILL
|
|
|
|
#define PR_MCE_KILL 33
|
|
|
|
#endif
|
|
|
|
|
2011-02-01 22:15:58 +01:00
|
|
|
#ifndef PR_MCE_KILL_SET
|
|
|
|
#define PR_MCE_KILL_SET 1
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef PR_MCE_KILL_EARLY
|
|
|
|
#define PR_MCE_KILL_EARLY 1
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif /* CONFIG_LINUX */
|
|
|
|
|
2014-07-25 11:56:33 +02:00
|
|
|
int64_t max_delay;
|
|
|
|
int64_t max_advance;
|
2010-03-29 21:23:50 +02:00
|
|
|
|
2015-09-08 19:12:33 +02:00
|
|
|
/* vcpu throttling controls */
|
|
|
|
static QEMUTimer *throttle_timer;
|
|
|
|
static unsigned int throttle_percentage;
|
|
|
|
|
|
|
|
#define CPU_THROTTLE_PCT_MIN 1
|
|
|
|
#define CPU_THROTTLE_PCT_MAX 99
|
|
|
|
#define CPU_THROTTLE_TIMESLICE_NS 10000000
|
|
|
|
|
2013-08-02 03:43:09 +02:00
|
|
|
bool cpu_is_stopped(CPUState *cpu)
|
|
|
|
{
|
|
|
|
return cpu->stopped || !runstate_is_running();
|
|
|
|
}
|
|
|
|
|
2013-05-26 23:21:08 +02:00
|
|
|
static bool cpu_thread_is_idle(CPUState *cpu)
|
2012-07-19 17:52:27 +02:00
|
|
|
{
|
2012-05-03 02:11:45 +02:00
|
|
|
if (cpu->stop || cpu->queued_work_first) {
|
2012-07-19 17:52:27 +02:00
|
|
|
return false;
|
|
|
|
}
|
2013-08-02 03:43:09 +02:00
|
|
|
if (cpu_is_stopped(cpu)) {
|
2012-07-19 17:52:27 +02:00
|
|
|
return true;
|
|
|
|
}
|
2013-08-25 18:53:55 +02:00
|
|
|
if (!cpu->halted || cpu_has_work(cpu) ||
|
2013-04-24 22:24:12 +02:00
|
|
|
kvm_halt_in_kernel()) {
|
2012-07-19 17:52:27 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool all_cpu_threads_idle(void)
|
|
|
|
{
|
2013-05-29 22:29:20 +02:00
|
|
|
CPUState *cpu;
|
2012-07-19 17:52:27 +02:00
|
|
|
|
2013-06-24 23:50:24 +02:00
|
|
|
CPU_FOREACH(cpu) {
|
2013-05-29 22:29:20 +02:00
|
|
|
if (!cpu_thread_is_idle(cpu)) {
|
2012-07-19 17:52:27 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-09-12 13:57:37 +02:00
|
|
|
/***********************************************************/
|
|
|
|
/* guest cycle counter */
|
|
|
|
|
2013-10-07 17:18:15 +02:00
|
|
|
/* Protected by TimersState seqlock */
|
|
|
|
|
2015-05-29 17:14:04 +02:00
|
|
|
static bool icount_sleep = true;
|
2011-09-12 13:57:37 +02:00
|
|
|
/* Conversion factor from emulated instructions to virtual clock ticks. */
|
|
|
|
static int icount_time_shift;
|
|
|
|
/* Arbitrarily pick 1MIPS as the minimum allowable speed. */
|
|
|
|
#define MAX_ICOUNT_SHIFT 10
|
2013-10-07 17:18:15 +02:00
|
|
|
|
2011-09-12 13:57:37 +02:00
|
|
|
typedef struct TimersState {
|
2013-09-25 08:20:58 +02:00
|
|
|
/* Protected by BQL. */
|
2011-09-12 13:57:37 +02:00
|
|
|
int64_t cpu_ticks_prev;
|
|
|
|
int64_t cpu_ticks_offset;
|
2013-09-25 08:20:58 +02:00
|
|
|
|
|
|
|
/* cpu_clock_offset can be read out of BQL, so protect it with
|
|
|
|
* this lock.
|
|
|
|
*/
|
|
|
|
QemuSeqLock vm_clock_seqlock;
|
2011-09-12 13:57:37 +02:00
|
|
|
int64_t cpu_clock_offset;
|
|
|
|
int32_t cpu_ticks_enabled;
|
|
|
|
int64_t dummy;
|
2014-08-01 01:37:09 +02:00
|
|
|
|
|
|
|
/* Compensate for varying guest execution speed. */
|
|
|
|
int64_t qemu_icount_bias;
|
|
|
|
/* Only written by TCG thread */
|
|
|
|
int64_t qemu_icount;
|
2018-01-11 09:26:10 +01:00
|
|
|
/* for adjusting icount */
|
|
|
|
int64_t vm_clock_warp_start;
|
|
|
|
QEMUTimer *icount_rt_timer;
|
|
|
|
QEMUTimer *icount_vm_timer;
|
|
|
|
QEMUTimer *icount_warp_timer;
|
2011-09-12 13:57:37 +02:00
|
|
|
} TimersState;
|
|
|
|
|
2013-07-21 10:43:00 +02:00
|
|
|
static TimersState timers_state;
|
2017-02-23 19:29:08 +01:00
|
|
|
bool mttcg_enabled;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We default to false if we know other options have been enabled
|
|
|
|
* which are currently incompatible with MTTCG. Otherwise when each
|
|
|
|
* guest (target) has been updated to support:
|
|
|
|
* - atomic instructions
|
|
|
|
* - memory ordering primitives (barriers)
|
|
|
|
* they can set the appropriate CONFIG flags in ${target}-softmmu.mak
|
|
|
|
*
|
|
|
|
* Once a guest architecture has been converted to the new primitives
|
|
|
|
* there are two remaining limitations to check.
|
|
|
|
*
|
|
|
|
* - The guest can't be oversized (e.g. 64 bit guest on 32 bit host)
|
|
|
|
* - The host must have a stronger memory order than the guest
|
|
|
|
*
|
|
|
|
* It may be possible in future to support strong guests on weak hosts
|
|
|
|
* but that will require tagging all load/stores in a guest with their
|
|
|
|
* implicit memory order requirements which would likely slow things
|
|
|
|
* down a lot.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static bool check_tcg_memory_orders_compatible(void)
|
|
|
|
{
|
|
|
|
#if defined(TCG_GUEST_DEFAULT_MO) && defined(TCG_TARGET_DEFAULT_MO)
|
|
|
|
return (TCG_GUEST_DEFAULT_MO & ~TCG_TARGET_DEFAULT_MO) == 0;
|
|
|
|
#else
|
|
|
|
return false;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool default_mttcg_enabled(void)
|
|
|
|
{
|
2017-02-27 18:09:01 +01:00
|
|
|
if (use_icount || TCG_OVERSIZED_GUEST) {
|
2017-02-23 19:29:08 +01:00
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
#ifdef TARGET_SUPPORTS_MTTCG
|
|
|
|
return check_tcg_memory_orders_compatible();
|
|
|
|
#else
|
|
|
|
return false;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void qemu_tcg_configure(QemuOpts *opts, Error **errp)
|
|
|
|
{
|
|
|
|
const char *t = qemu_opt_get(opts, "thread");
|
|
|
|
if (t) {
|
|
|
|
if (strcmp(t, "multi") == 0) {
|
|
|
|
if (TCG_OVERSIZED_GUEST) {
|
|
|
|
error_setg(errp, "No MTTCG when guest word size > hosts");
|
2017-02-27 18:09:01 +01:00
|
|
|
} else if (use_icount) {
|
|
|
|
error_setg(errp, "No MTTCG when icount is enabled");
|
2017-02-23 19:29:08 +01:00
|
|
|
} else {
|
2017-04-10 08:06:55 +02:00
|
|
|
#ifndef TARGET_SUPPORTS_MTTCG
|
2017-02-28 15:40:17 +01:00
|
|
|
error_report("Guest not yet converted to MTTCG - "
|
|
|
|
"you may get unexpected results");
|
|
|
|
#endif
|
2017-02-23 19:29:08 +01:00
|
|
|
if (!check_tcg_memory_orders_compatible()) {
|
|
|
|
error_report("Guest expects a stronger memory ordering "
|
|
|
|
"than the host provides");
|
2017-03-25 21:19:23 +01:00
|
|
|
error_printf("This may cause strange/hard to debug errors\n");
|
2017-02-23 19:29:08 +01:00
|
|
|
}
|
|
|
|
mttcg_enabled = true;
|
|
|
|
}
|
|
|
|
} else if (strcmp(t, "single") == 0) {
|
|
|
|
mttcg_enabled = false;
|
|
|
|
} else {
|
|
|
|
error_setg(errp, "Invalid 'thread' setting %s", t);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
mttcg_enabled = default_mttcg_enabled();
|
|
|
|
}
|
|
|
|
}
|
2011-09-12 13:57:37 +02:00
|
|
|
|
2017-03-31 17:09:42 +02:00
|
|
|
/* The current number of executed instructions is based on what we
|
|
|
|
* originally budgeted minus the current state of the decrementing
|
|
|
|
* icount counters in extra/u16.low.
|
|
|
|
*/
|
|
|
|
static int64_t cpu_get_icount_executed(CPUState *cpu)
|
|
|
|
{
|
|
|
|
return cpu->icount_budget - (cpu->icount_decr.u16.low + cpu->icount_extra);
|
|
|
|
}
|
|
|
|
|
2017-04-05 13:32:37 +02:00
|
|
|
/*
|
|
|
|
* Update the global shared timer_state.qemu_icount to take into
|
|
|
|
* account executed instructions. This is done by the TCG vCPU
|
|
|
|
* thread so the main-loop can see time has moved forward.
|
|
|
|
*/
|
|
|
|
void cpu_update_icount(CPUState *cpu)
|
|
|
|
{
|
|
|
|
int64_t executed = cpu_get_icount_executed(cpu);
|
|
|
|
cpu->icount_budget -= executed;
|
|
|
|
|
|
|
|
#ifdef CONFIG_ATOMIC64
|
|
|
|
atomic_set__nocheck(&timers_state.qemu_icount,
|
|
|
|
atomic_read__nocheck(&timers_state.qemu_icount) +
|
|
|
|
executed);
|
|
|
|
#else /* FIXME: we need 64bit atomics to do this safely */
|
|
|
|
timers_state.qemu_icount += executed;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-12-08 08:53:45 +01:00
|
|
|
int64_t cpu_get_icount_raw(void)
|
2011-09-12 13:57:37 +02:00
|
|
|
{
|
2013-05-27 05:17:50 +02:00
|
|
|
CPUState *cpu = current_cpu;
|
2011-09-12 13:57:37 +02:00
|
|
|
|
2017-03-30 19:49:22 +02:00
|
|
|
if (cpu && cpu->running) {
|
2015-06-24 14:16:26 +02:00
|
|
|
if (!cpu->can_do_io) {
|
tcg: Replace fprintf(stderr, "*\n" with error_report()
Replace a large number of the fprintf(stderr, "*\n" calls with
error_report(). The functions were renamed with these commands and then
compiler issues where manually fixed.
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
Signed-off-by: Alistair Francis <alistair.francis@xilinx.com>
Cc: Paolo Bonzini <pbonzini@redhat.com>
Cc: Peter Crosthwaite <crosthwaite.peter@gmail.com>
Cc: Richard Henderson <rth@twiddle.net>
Cc: Stefan Weil <sw@weilnetz.de>
Conversions that aren't followed by exit() dropped, because they might
be inappropriate.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Message-Id: <20180203084315.20497-14-armbru@redhat.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
2018-02-03 09:43:14 +01:00
|
|
|
error_report("Bad icount read");
|
2014-12-08 08:53:45 +01:00
|
|
|
exit(1);
|
2011-09-12 13:57:37 +02:00
|
|
|
}
|
2017-03-31 17:09:42 +02:00
|
|
|
/* Take into account what has run */
|
2017-04-05 11:53:47 +02:00
|
|
|
cpu_update_icount(cpu);
|
2011-09-12 13:57:37 +02:00
|
|
|
}
|
2017-04-05 11:53:47 +02:00
|
|
|
#ifdef CONFIG_ATOMIC64
|
|
|
|
return atomic_read__nocheck(&timers_state.qemu_icount);
|
|
|
|
#else /* FIXME: we need 64bit atomics to do this safely */
|
|
|
|
return timers_state.qemu_icount;
|
|
|
|
#endif
|
2014-12-08 08:53:45 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Return the virtual CPU time, based on the instruction counter. */
|
|
|
|
static int64_t cpu_get_icount_locked(void)
|
|
|
|
{
|
|
|
|
int64_t icount = cpu_get_icount_raw();
|
2014-08-01 01:37:15 +02:00
|
|
|
return timers_state.qemu_icount_bias + cpu_icount_to_ns(icount);
|
2011-09-12 13:57:37 +02:00
|
|
|
}
|
|
|
|
|
2013-10-03 15:17:25 +02:00
|
|
|
int64_t cpu_get_icount(void)
|
|
|
|
{
|
|
|
|
int64_t icount;
|
|
|
|
unsigned start;
|
|
|
|
|
|
|
|
do {
|
|
|
|
start = seqlock_read_begin(&timers_state.vm_clock_seqlock);
|
|
|
|
icount = cpu_get_icount_locked();
|
|
|
|
} while (seqlock_read_retry(&timers_state.vm_clock_seqlock, start));
|
|
|
|
|
|
|
|
return icount;
|
|
|
|
}
|
|
|
|
|
2014-08-01 01:37:15 +02:00
|
|
|
int64_t cpu_icount_to_ns(int64_t icount)
|
|
|
|
{
|
|
|
|
return icount << icount_time_shift;
|
|
|
|
}
|
|
|
|
|
2016-07-29 13:05:38 +02:00
|
|
|
/* return the time elapsed in VM between vm_start and vm_stop. Unless
|
|
|
|
* icount is active, cpu_get_ticks() uses units of the host CPU cycle
|
|
|
|
* counter.
|
|
|
|
*
|
|
|
|
* Caller must hold the BQL
|
|
|
|
*/
|
2011-09-12 13:57:37 +02:00
|
|
|
int64_t cpu_get_ticks(void)
|
|
|
|
{
|
2013-10-28 17:32:18 +01:00
|
|
|
int64_t ticks;
|
|
|
|
|
2011-09-12 13:57:37 +02:00
|
|
|
if (use_icount) {
|
|
|
|
return cpu_get_icount();
|
|
|
|
}
|
2013-10-28 17:32:18 +01:00
|
|
|
|
|
|
|
ticks = timers_state.cpu_ticks_offset;
|
|
|
|
if (timers_state.cpu_ticks_enabled) {
|
2015-09-25 16:42:21 +02:00
|
|
|
ticks += cpu_get_host_ticks();
|
2013-10-28 17:32:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (timers_state.cpu_ticks_prev > ticks) {
|
|
|
|
/* Note: non increasing ticks may happen if the host uses
|
|
|
|
software suspend */
|
|
|
|
timers_state.cpu_ticks_offset += timers_state.cpu_ticks_prev - ticks;
|
|
|
|
ticks = timers_state.cpu_ticks_prev;
|
2011-09-12 13:57:37 +02:00
|
|
|
}
|
2013-10-28 17:32:18 +01:00
|
|
|
|
|
|
|
timers_state.cpu_ticks_prev = ticks;
|
|
|
|
return ticks;
|
2011-09-12 13:57:37 +02:00
|
|
|
}
|
|
|
|
|
2013-09-25 08:20:58 +02:00
|
|
|
static int64_t cpu_get_clock_locked(void)
|
2011-09-12 13:57:37 +02:00
|
|
|
{
|
2016-07-29 13:05:37 +02:00
|
|
|
int64_t time;
|
2013-09-25 08:20:58 +02:00
|
|
|
|
2016-07-29 13:05:37 +02:00
|
|
|
time = timers_state.cpu_clock_offset;
|
2013-10-28 17:32:18 +01:00
|
|
|
if (timers_state.cpu_ticks_enabled) {
|
2016-07-29 13:05:37 +02:00
|
|
|
time += get_clock();
|
2011-09-12 13:57:37 +02:00
|
|
|
}
|
2013-09-25 08:20:58 +02:00
|
|
|
|
2016-07-29 13:05:37 +02:00
|
|
|
return time;
|
2013-09-25 08:20:58 +02:00
|
|
|
}
|
|
|
|
|
2016-07-29 13:05:38 +02:00
|
|
|
/* Return the monotonic time elapsed in VM, i.e.,
|
2016-09-15 11:24:22 +02:00
|
|
|
* the time between vm_start and vm_stop
|
|
|
|
*/
|
2013-09-25 08:20:58 +02:00
|
|
|
int64_t cpu_get_clock(void)
|
|
|
|
{
|
|
|
|
int64_t ti;
|
|
|
|
unsigned start;
|
|
|
|
|
|
|
|
do {
|
|
|
|
start = seqlock_read_begin(&timers_state.vm_clock_seqlock);
|
|
|
|
ti = cpu_get_clock_locked();
|
|
|
|
} while (seqlock_read_retry(&timers_state.vm_clock_seqlock, start));
|
|
|
|
|
|
|
|
return ti;
|
2011-09-12 13:57:37 +02:00
|
|
|
}
|
|
|
|
|
2013-09-25 08:20:58 +02:00
|
|
|
/* enable cpu_get_ticks()
|
2016-07-08 12:31:37 +02:00
|
|
|
* Caller must hold BQL which serves as mutex for vm_clock_seqlock.
|
2013-09-25 08:20:58 +02:00
|
|
|
*/
|
2011-09-12 13:57:37 +02:00
|
|
|
void cpu_enable_ticks(void)
|
|
|
|
{
|
2013-09-25 08:20:58 +02:00
|
|
|
/* Here, the really thing protected by seqlock is cpu_clock_offset. */
|
2016-06-08 20:55:21 +02:00
|
|
|
seqlock_write_begin(&timers_state.vm_clock_seqlock);
|
2011-09-12 13:57:37 +02:00
|
|
|
if (!timers_state.cpu_ticks_enabled) {
|
2015-09-25 16:42:21 +02:00
|
|
|
timers_state.cpu_ticks_offset -= cpu_get_host_ticks();
|
2011-09-12 13:57:37 +02:00
|
|
|
timers_state.cpu_clock_offset -= get_clock();
|
|
|
|
timers_state.cpu_ticks_enabled = 1;
|
|
|
|
}
|
2016-06-08 20:55:21 +02:00
|
|
|
seqlock_write_end(&timers_state.vm_clock_seqlock);
|
2011-09-12 13:57:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* disable cpu_get_ticks() : the clock is stopped. You must not call
|
2013-09-25 08:20:58 +02:00
|
|
|
* cpu_get_ticks() after that.
|
2016-07-08 12:31:37 +02:00
|
|
|
* Caller must hold BQL which serves as mutex for vm_clock_seqlock.
|
2013-09-25 08:20:58 +02:00
|
|
|
*/
|
2011-09-12 13:57:37 +02:00
|
|
|
void cpu_disable_ticks(void)
|
|
|
|
{
|
2013-09-25 08:20:58 +02:00
|
|
|
/* Here, the really thing protected by seqlock is cpu_clock_offset. */
|
2016-06-08 20:55:21 +02:00
|
|
|
seqlock_write_begin(&timers_state.vm_clock_seqlock);
|
2011-09-12 13:57:37 +02:00
|
|
|
if (timers_state.cpu_ticks_enabled) {
|
2015-09-25 16:42:21 +02:00
|
|
|
timers_state.cpu_ticks_offset += cpu_get_host_ticks();
|
2013-09-25 08:20:58 +02:00
|
|
|
timers_state.cpu_clock_offset = cpu_get_clock_locked();
|
2011-09-12 13:57:37 +02:00
|
|
|
timers_state.cpu_ticks_enabled = 0;
|
|
|
|
}
|
2016-06-08 20:55:21 +02:00
|
|
|
seqlock_write_end(&timers_state.vm_clock_seqlock);
|
2011-09-12 13:57:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Correlation between real and virtual time is always going to be
|
|
|
|
fairly approximate, so ignore small variation.
|
|
|
|
When the guest is idle real and virtual time will be aligned in
|
|
|
|
the IO wait loop. */
|
2016-03-21 17:02:30 +01:00
|
|
|
#define ICOUNT_WOBBLE (NANOSECONDS_PER_SECOND / 10)
|
2011-09-12 13:57:37 +02:00
|
|
|
|
|
|
|
static void icount_adjust(void)
|
|
|
|
{
|
|
|
|
int64_t cur_time;
|
|
|
|
int64_t cur_icount;
|
|
|
|
int64_t delta;
|
2013-10-07 17:18:15 +02:00
|
|
|
|
|
|
|
/* Protected by TimersState mutex. */
|
2011-09-12 13:57:37 +02:00
|
|
|
static int64_t last_delta;
|
2013-10-07 17:21:51 +02:00
|
|
|
|
2011-09-12 13:57:37 +02:00
|
|
|
/* If the VM is not running, then do nothing. */
|
|
|
|
if (!runstate_is_running()) {
|
|
|
|
return;
|
|
|
|
}
|
2013-10-07 17:21:51 +02:00
|
|
|
|
2016-06-08 20:55:21 +02:00
|
|
|
seqlock_write_begin(&timers_state.vm_clock_seqlock);
|
2013-10-03 15:17:25 +02:00
|
|
|
cur_time = cpu_get_clock_locked();
|
|
|
|
cur_icount = cpu_get_icount_locked();
|
2013-10-07 17:21:51 +02:00
|
|
|
|
2011-09-12 13:57:37 +02:00
|
|
|
delta = cur_icount - cur_time;
|
|
|
|
/* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
|
|
|
|
if (delta > 0
|
|
|
|
&& last_delta + ICOUNT_WOBBLE < delta * 2
|
|
|
|
&& icount_time_shift > 0) {
|
|
|
|
/* The guest is getting too far ahead. Slow time down. */
|
|
|
|
icount_time_shift--;
|
|
|
|
}
|
|
|
|
if (delta < 0
|
|
|
|
&& last_delta - ICOUNT_WOBBLE > delta * 2
|
|
|
|
&& icount_time_shift < MAX_ICOUNT_SHIFT) {
|
|
|
|
/* The guest is getting too far behind. Speed time up. */
|
|
|
|
icount_time_shift++;
|
|
|
|
}
|
|
|
|
last_delta = delta;
|
2014-08-01 01:37:09 +02:00
|
|
|
timers_state.qemu_icount_bias = cur_icount
|
|
|
|
- (timers_state.qemu_icount << icount_time_shift);
|
2016-06-08 20:55:21 +02:00
|
|
|
seqlock_write_end(&timers_state.vm_clock_seqlock);
|
2011-09-12 13:57:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void icount_adjust_rt(void *opaque)
|
|
|
|
{
|
2018-01-11 09:26:10 +01:00
|
|
|
timer_mod(timers_state.icount_rt_timer,
|
2015-01-12 13:00:43 +01:00
|
|
|
qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT) + 1000);
|
2011-09-12 13:57:37 +02:00
|
|
|
icount_adjust();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void icount_adjust_vm(void *opaque)
|
|
|
|
{
|
2018-01-11 09:26:10 +01:00
|
|
|
timer_mod(timers_state.icount_vm_timer,
|
2013-08-21 17:03:02 +02:00
|
|
|
qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
|
2016-03-21 17:02:30 +01:00
|
|
|
NANOSECONDS_PER_SECOND / 10);
|
2011-09-12 13:57:37 +02:00
|
|
|
icount_adjust();
|
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t qemu_icount_round(int64_t count)
|
|
|
|
{
|
|
|
|
return (count + (1 << icount_time_shift) - 1) >> icount_time_shift;
|
|
|
|
}
|
|
|
|
|
2015-09-17 18:24:39 +02:00
|
|
|
static void icount_warp_rt(void)
|
2011-09-12 13:57:37 +02:00
|
|
|
{
|
2016-04-04 16:35:48 +02:00
|
|
|
unsigned seq;
|
|
|
|
int64_t warp_start;
|
|
|
|
|
2013-10-03 15:17:25 +02:00
|
|
|
/* The icount_warp_timer is rescheduled soon after vm_clock_warp_start
|
|
|
|
* changes from -1 to another value, so the race here is okay.
|
|
|
|
*/
|
2016-04-04 16:35:48 +02:00
|
|
|
do {
|
|
|
|
seq = seqlock_read_begin(&timers_state.vm_clock_seqlock);
|
2018-01-11 09:26:10 +01:00
|
|
|
warp_start = timers_state.vm_clock_warp_start;
|
2016-04-04 16:35:48 +02:00
|
|
|
} while (seqlock_read_retry(&timers_state.vm_clock_seqlock, seq));
|
|
|
|
|
|
|
|
if (warp_start == -1) {
|
2011-09-12 13:57:37 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-08 20:55:21 +02:00
|
|
|
seqlock_write_begin(&timers_state.vm_clock_seqlock);
|
2011-09-12 13:57:37 +02:00
|
|
|
if (runstate_is_running()) {
|
2015-09-17 18:24:28 +02:00
|
|
|
int64_t clock = REPLAY_CLOCK(REPLAY_CLOCK_VIRTUAL_RT,
|
|
|
|
cpu_get_clock_locked());
|
2013-10-07 17:26:07 +02:00
|
|
|
int64_t warp_delta;
|
|
|
|
|
2018-01-11 09:26:10 +01:00
|
|
|
warp_delta = clock - timers_state.vm_clock_warp_start;
|
2013-10-07 17:26:07 +02:00
|
|
|
if (use_icount == 2) {
|
2011-09-12 13:57:37 +02:00
|
|
|
/*
|
2013-08-21 17:03:02 +02:00
|
|
|
* In adaptive mode, do not let QEMU_CLOCK_VIRTUAL run too
|
2011-09-12 13:57:37 +02:00
|
|
|
* far ahead of real time.
|
|
|
|
*/
|
2013-10-03 15:17:25 +02:00
|
|
|
int64_t cur_icount = cpu_get_icount_locked();
|
2014-11-26 11:40:55 +01:00
|
|
|
int64_t delta = clock - cur_icount;
|
2013-10-07 17:26:07 +02:00
|
|
|
warp_delta = MIN(warp_delta, delta);
|
2011-09-12 13:57:37 +02:00
|
|
|
}
|
2014-08-01 01:37:09 +02:00
|
|
|
timers_state.qemu_icount_bias += warp_delta;
|
2011-09-12 13:57:37 +02:00
|
|
|
}
|
2018-01-11 09:26:10 +01:00
|
|
|
timers_state.vm_clock_warp_start = -1;
|
2016-06-08 20:55:21 +02:00
|
|
|
seqlock_write_end(&timers_state.vm_clock_seqlock);
|
2013-10-07 17:26:07 +02:00
|
|
|
|
|
|
|
if (qemu_clock_expired(QEMU_CLOCK_VIRTUAL)) {
|
|
|
|
qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
|
|
|
|
}
|
2011-09-12 13:57:37 +02:00
|
|
|
}
|
|
|
|
|
2016-03-10 12:56:09 +01:00
|
|
|
static void icount_timer_cb(void *opaque)
|
2015-09-17 18:24:39 +02:00
|
|
|
{
|
2016-03-10 12:56:09 +01:00
|
|
|
/* No need for a checkpoint because the timer already synchronizes
|
|
|
|
* with CHECKPOINT_CLOCK_VIRTUAL_RT.
|
|
|
|
*/
|
|
|
|
icount_warp_rt();
|
2015-09-17 18:24:39 +02:00
|
|
|
}
|
|
|
|
|
2012-03-28 15:42:04 +02:00
|
|
|
void qtest_clock_warp(int64_t dest)
|
|
|
|
{
|
2013-08-21 17:03:02 +02:00
|
|
|
int64_t clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
|
2015-01-19 10:51:43 +01:00
|
|
|
AioContext *aio_context;
|
2012-03-28 15:42:04 +02:00
|
|
|
assert(qtest_enabled());
|
2015-01-19 10:51:43 +01:00
|
|
|
aio_context = qemu_get_aio_context();
|
2012-03-28 15:42:04 +02:00
|
|
|
while (clock < dest) {
|
2013-08-21 17:03:02 +02:00
|
|
|
int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
|
2014-06-10 11:10:28 +02:00
|
|
|
int64_t warp = qemu_soonest_timeout(dest - clock, deadline);
|
2015-01-19 10:51:43 +01:00
|
|
|
|
2016-06-08 20:55:21 +02:00
|
|
|
seqlock_write_begin(&timers_state.vm_clock_seqlock);
|
2014-08-01 01:37:09 +02:00
|
|
|
timers_state.qemu_icount_bias += warp;
|
2016-06-08 20:55:21 +02:00
|
|
|
seqlock_write_end(&timers_state.vm_clock_seqlock);
|
2013-10-03 15:17:25 +02:00
|
|
|
|
2013-08-21 17:03:02 +02:00
|
|
|
qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
|
2015-01-19 10:51:43 +01:00
|
|
|
timerlist_run_timers(aio_context->tlg.tl[QEMU_CLOCK_VIRTUAL]);
|
2013-08-21 17:03:02 +02:00
|
|
|
clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
|
2012-03-28 15:42:04 +02:00
|
|
|
}
|
2013-08-21 17:03:02 +02:00
|
|
|
qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
|
2012-03-28 15:42:04 +02:00
|
|
|
}
|
|
|
|
|
2016-03-10 12:56:09 +01:00
|
|
|
void qemu_start_warp_timer(void)
|
2011-09-12 13:57:37 +02:00
|
|
|
{
|
2013-10-07 17:30:02 +02:00
|
|
|
int64_t clock;
|
2011-09-12 13:57:37 +02:00
|
|
|
int64_t deadline;
|
|
|
|
|
2016-03-10 12:56:09 +01:00
|
|
|
if (!use_icount) {
|
2011-09-12 13:57:37 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-09-17 18:24:44 +02:00
|
|
|
/* Nothing to do if the VM is stopped: QEMU_CLOCK_VIRTUAL timers
|
|
|
|
* do not fire, so computing the deadline does not make sense.
|
|
|
|
*/
|
|
|
|
if (!runstate_is_running()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* warp clock deterministically in record/replay mode */
|
2016-03-10 12:56:09 +01:00
|
|
|
if (!replay_checkpoint(CHECKPOINT_CLOCK_WARP_START)) {
|
2015-09-17 18:24:44 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-10-07 17:30:02 +02:00
|
|
|
if (!all_cpu_threads_idle()) {
|
2011-09-12 13:57:37 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-03-28 15:42:04 +02:00
|
|
|
if (qtest_enabled()) {
|
|
|
|
/* When testing, qtest commands advance icount. */
|
2016-03-10 12:56:09 +01:00
|
|
|
return;
|
2012-03-28 15:42:04 +02:00
|
|
|
}
|
|
|
|
|
2013-08-21 17:02:57 +02:00
|
|
|
/* We want to use the earliest deadline from ALL vm_clocks */
|
2014-11-26 11:40:55 +01:00
|
|
|
clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT);
|
2013-08-21 17:03:02 +02:00
|
|
|
deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
|
2013-10-07 17:30:02 +02:00
|
|
|
if (deadline < 0) {
|
2015-05-29 17:14:06 +02:00
|
|
|
static bool notified;
|
|
|
|
if (!icount_sleep && !notified) {
|
2017-07-12 15:57:41 +02:00
|
|
|
warn_report("icount sleep disabled and no active timers");
|
2015-05-29 17:14:06 +02:00
|
|
|
notified = true;
|
|
|
|
}
|
2013-10-07 17:30:02 +02:00
|
|
|
return;
|
2013-08-21 17:02:57 +02:00
|
|
|
}
|
|
|
|
|
2011-09-12 13:57:37 +02:00
|
|
|
if (deadline > 0) {
|
|
|
|
/*
|
2013-08-21 17:03:02 +02:00
|
|
|
* Ensure QEMU_CLOCK_VIRTUAL proceeds even when the virtual CPU goes to
|
2011-09-12 13:57:37 +02:00
|
|
|
* sleep. Otherwise, the CPU might be waiting for a future timer
|
|
|
|
* interrupt to wake it up, but the interrupt never comes because
|
|
|
|
* the vCPU isn't running any insns and thus doesn't advance the
|
2013-08-21 17:03:02 +02:00
|
|
|
* QEMU_CLOCK_VIRTUAL.
|
2011-09-12 13:57:37 +02:00
|
|
|
*/
|
2015-05-29 17:14:04 +02:00
|
|
|
if (!icount_sleep) {
|
|
|
|
/*
|
|
|
|
* We never let VCPUs sleep in no sleep icount mode.
|
|
|
|
* If there is a pending QEMU_CLOCK_VIRTUAL timer we just advance
|
|
|
|
* to the next QEMU_CLOCK_VIRTUAL event and notify it.
|
|
|
|
* It is useful when we want a deterministic execution time,
|
|
|
|
* isolated from host latencies.
|
|
|
|
*/
|
2016-06-08 20:55:21 +02:00
|
|
|
seqlock_write_begin(&timers_state.vm_clock_seqlock);
|
2015-05-29 17:14:04 +02:00
|
|
|
timers_state.qemu_icount_bias += deadline;
|
2016-06-08 20:55:21 +02:00
|
|
|
seqlock_write_end(&timers_state.vm_clock_seqlock);
|
2015-05-29 17:14:04 +02:00
|
|
|
qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We do stop VCPUs and only advance QEMU_CLOCK_VIRTUAL after some
|
|
|
|
* "real" time, (related to the time left until the next event) has
|
|
|
|
* passed. The QEMU_CLOCK_VIRTUAL_RT clock will do this.
|
|
|
|
* This avoids that the warps are visible externally; for example,
|
|
|
|
* you will not be sending network packets continuously instead of
|
|
|
|
* every 100ms.
|
|
|
|
*/
|
2016-06-08 20:55:21 +02:00
|
|
|
seqlock_write_begin(&timers_state.vm_clock_seqlock);
|
2018-01-11 09:26:10 +01:00
|
|
|
if (timers_state.vm_clock_warp_start == -1
|
|
|
|
|| timers_state.vm_clock_warp_start > clock) {
|
|
|
|
timers_state.vm_clock_warp_start = clock;
|
2015-05-29 17:14:04 +02:00
|
|
|
}
|
2016-06-08 20:55:21 +02:00
|
|
|
seqlock_write_end(&timers_state.vm_clock_seqlock);
|
2018-01-11 09:26:10 +01:00
|
|
|
timer_mod_anticipate(timers_state.icount_warp_timer,
|
|
|
|
clock + deadline);
|
2013-10-07 17:30:02 +02:00
|
|
|
}
|
2013-08-21 17:02:57 +02:00
|
|
|
} else if (deadline == 0) {
|
2013-08-21 17:03:02 +02:00
|
|
|
qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
|
2011-09-12 13:57:37 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-10 12:56:09 +01:00
|
|
|
static void qemu_account_warp_timer(void)
|
|
|
|
{
|
|
|
|
if (!use_icount || !icount_sleep) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Nothing to do if the VM is stopped: QEMU_CLOCK_VIRTUAL timers
|
|
|
|
* do not fire, so computing the deadline does not make sense.
|
|
|
|
*/
|
|
|
|
if (!runstate_is_running()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* warp clock deterministically in record/replay mode */
|
|
|
|
if (!replay_checkpoint(CHECKPOINT_CLOCK_WARP_ACCOUNT)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-01-11 09:26:10 +01:00
|
|
|
timer_del(timers_state.icount_warp_timer);
|
2016-03-10 12:56:09 +01:00
|
|
|
icount_warp_rt();
|
|
|
|
}
|
|
|
|
|
2014-08-01 01:37:10 +02:00
|
|
|
static bool icount_state_needed(void *opaque)
|
|
|
|
{
|
|
|
|
return use_icount;
|
|
|
|
}
|
|
|
|
|
2018-01-11 09:26:10 +01:00
|
|
|
static bool warp_timer_state_needed(void *opaque)
|
|
|
|
{
|
|
|
|
TimersState *s = opaque;
|
|
|
|
return s->icount_warp_timer != NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool adjust_timers_state_needed(void *opaque)
|
|
|
|
{
|
|
|
|
TimersState *s = opaque;
|
|
|
|
return s->icount_rt_timer != NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Subsection for warp timer migration is optional, because may not be created
|
|
|
|
*/
|
|
|
|
static const VMStateDescription icount_vmstate_warp_timer = {
|
|
|
|
.name = "timer/icount/warp_timer",
|
|
|
|
.version_id = 1,
|
|
|
|
.minimum_version_id = 1,
|
|
|
|
.needed = warp_timer_state_needed,
|
|
|
|
.fields = (VMStateField[]) {
|
|
|
|
VMSTATE_INT64(vm_clock_warp_start, TimersState),
|
|
|
|
VMSTATE_TIMER_PTR(icount_warp_timer, TimersState),
|
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static const VMStateDescription icount_vmstate_adjust_timers = {
|
|
|
|
.name = "timer/icount/timers",
|
|
|
|
.version_id = 1,
|
|
|
|
.minimum_version_id = 1,
|
|
|
|
.needed = adjust_timers_state_needed,
|
|
|
|
.fields = (VMStateField[]) {
|
|
|
|
VMSTATE_TIMER_PTR(icount_rt_timer, TimersState),
|
|
|
|
VMSTATE_TIMER_PTR(icount_vm_timer, TimersState),
|
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2014-08-01 01:37:10 +02:00
|
|
|
/*
|
|
|
|
* This is a subsection for icount migration.
|
|
|
|
*/
|
|
|
|
static const VMStateDescription icount_vmstate_timers = {
|
|
|
|
.name = "timer/icount",
|
|
|
|
.version_id = 1,
|
|
|
|
.minimum_version_id = 1,
|
2014-09-23 14:09:54 +02:00
|
|
|
.needed = icount_state_needed,
|
2014-08-01 01:37:10 +02:00
|
|
|
.fields = (VMStateField[]) {
|
|
|
|
VMSTATE_INT64(qemu_icount_bias, TimersState),
|
|
|
|
VMSTATE_INT64(qemu_icount, TimersState),
|
|
|
|
VMSTATE_END_OF_LIST()
|
2018-01-11 09:26:10 +01:00
|
|
|
},
|
|
|
|
.subsections = (const VMStateDescription*[]) {
|
|
|
|
&icount_vmstate_warp_timer,
|
|
|
|
&icount_vmstate_adjust_timers,
|
|
|
|
NULL
|
2014-08-01 01:37:10 +02:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-09-12 13:57:37 +02:00
|
|
|
static const VMStateDescription vmstate_timers = {
|
|
|
|
.name = "timer",
|
|
|
|
.version_id = 2,
|
|
|
|
.minimum_version_id = 1,
|
2014-04-16 16:01:33 +02:00
|
|
|
.fields = (VMStateField[]) {
|
2011-09-12 13:57:37 +02:00
|
|
|
VMSTATE_INT64(cpu_ticks_offset, TimersState),
|
|
|
|
VMSTATE_INT64(dummy, TimersState),
|
|
|
|
VMSTATE_INT64_V(cpu_clock_offset, TimersState, 2),
|
|
|
|
VMSTATE_END_OF_LIST()
|
2014-08-01 01:37:10 +02:00
|
|
|
},
|
2014-09-23 14:09:54 +02:00
|
|
|
.subsections = (const VMStateDescription*[]) {
|
|
|
|
&icount_vmstate_timers,
|
|
|
|
NULL
|
2011-09-12 13:57:37 +02:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2016-10-31 10:36:08 +01:00
|
|
|
static void cpu_throttle_thread(CPUState *cpu, run_on_cpu_data opaque)
|
2015-09-08 19:12:33 +02:00
|
|
|
{
|
|
|
|
double pct;
|
|
|
|
double throttle_ratio;
|
|
|
|
long sleeptime_ns;
|
|
|
|
|
|
|
|
if (!cpu_throttle_get_percentage()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
pct = (double)cpu_throttle_get_percentage()/100;
|
|
|
|
throttle_ratio = pct / (1 - pct);
|
|
|
|
sleeptime_ns = (long)(throttle_ratio * CPU_THROTTLE_TIMESLICE_NS);
|
|
|
|
|
|
|
|
qemu_mutex_unlock_iothread();
|
|
|
|
g_usleep(sleeptime_ns / 1000); /* Convert ns to us for usleep call */
|
|
|
|
qemu_mutex_lock_iothread();
|
2017-05-19 23:29:50 +02:00
|
|
|
atomic_set(&cpu->throttle_thread_scheduled, 0);
|
2015-09-08 19:12:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void cpu_throttle_timer_tick(void *opaque)
|
|
|
|
{
|
|
|
|
CPUState *cpu;
|
|
|
|
double pct;
|
|
|
|
|
|
|
|
/* Stop the timer if needed */
|
|
|
|
if (!cpu_throttle_get_percentage()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
CPU_FOREACH(cpu) {
|
|
|
|
if (!atomic_xchg(&cpu->throttle_thread_scheduled, 1)) {
|
2016-10-31 10:36:08 +01:00
|
|
|
async_run_on_cpu(cpu, cpu_throttle_thread,
|
|
|
|
RUN_ON_CPU_NULL);
|
2015-09-08 19:12:33 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pct = (double)cpu_throttle_get_percentage()/100;
|
|
|
|
timer_mod(throttle_timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT) +
|
|
|
|
CPU_THROTTLE_TIMESLICE_NS / (1-pct));
|
|
|
|
}
|
|
|
|
|
|
|
|
void cpu_throttle_set(int new_throttle_pct)
|
|
|
|
{
|
|
|
|
/* Ensure throttle percentage is within valid range */
|
|
|
|
new_throttle_pct = MIN(new_throttle_pct, CPU_THROTTLE_PCT_MAX);
|
|
|
|
new_throttle_pct = MAX(new_throttle_pct, CPU_THROTTLE_PCT_MIN);
|
|
|
|
|
|
|
|
atomic_set(&throttle_percentage, new_throttle_pct);
|
|
|
|
|
|
|
|
timer_mod(throttle_timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT) +
|
|
|
|
CPU_THROTTLE_TIMESLICE_NS);
|
|
|
|
}
|
|
|
|
|
|
|
|
void cpu_throttle_stop(void)
|
|
|
|
{
|
|
|
|
atomic_set(&throttle_percentage, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool cpu_throttle_active(void)
|
|
|
|
{
|
|
|
|
return (cpu_throttle_get_percentage() != 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
int cpu_throttle_get_percentage(void)
|
|
|
|
{
|
|
|
|
return atomic_read(&throttle_percentage);
|
|
|
|
}
|
|
|
|
|
2014-09-01 07:34:49 +02:00
|
|
|
void cpu_ticks_init(void)
|
|
|
|
{
|
2016-06-08 20:55:20 +02:00
|
|
|
seqlock_init(&timers_state.vm_clock_seqlock);
|
2014-09-01 07:34:49 +02:00
|
|
|
vmstate_register(NULL, 0, &vmstate_timers, &timers_state);
|
2015-09-08 19:12:33 +02:00
|
|
|
throttle_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL_RT,
|
|
|
|
cpu_throttle_timer_tick, NULL);
|
2014-09-01 07:34:49 +02:00
|
|
|
}
|
|
|
|
|
2014-07-25 11:56:28 +02:00
|
|
|
void configure_icount(QemuOpts *opts, Error **errp)
|
2011-09-12 13:57:37 +02:00
|
|
|
{
|
2014-07-25 11:56:28 +02:00
|
|
|
const char *option;
|
2014-07-25 11:56:29 +02:00
|
|
|
char *rem_str = NULL;
|
2014-07-25 11:56:28 +02:00
|
|
|
|
|
|
|
option = qemu_opt_get(opts, "shift");
|
2011-09-12 13:57:37 +02:00
|
|
|
if (!option) {
|
2014-07-25 11:56:29 +02:00
|
|
|
if (qemu_opt_get(opts, "align") != NULL) {
|
|
|
|
error_setg(errp, "Please specify shift option when using align");
|
|
|
|
}
|
2011-09-12 13:57:37 +02:00
|
|
|
return;
|
|
|
|
}
|
2015-05-29 17:14:05 +02:00
|
|
|
|
|
|
|
icount_sleep = qemu_opt_get_bool(opts, "sleep", true);
|
2015-05-29 17:14:04 +02:00
|
|
|
if (icount_sleep) {
|
2018-01-11 09:26:10 +01:00
|
|
|
timers_state.icount_warp_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL_RT,
|
2016-03-10 12:56:09 +01:00
|
|
|
icount_timer_cb, NULL);
|
2015-05-29 17:14:04 +02:00
|
|
|
}
|
2015-05-29 17:14:05 +02:00
|
|
|
|
2014-07-25 11:56:29 +02:00
|
|
|
icount_align_option = qemu_opt_get_bool(opts, "align", false);
|
2015-05-29 17:14:05 +02:00
|
|
|
|
|
|
|
if (icount_align_option && !icount_sleep) {
|
2016-02-26 16:16:51 +01:00
|
|
|
error_setg(errp, "align=on and sleep=off are incompatible");
|
2015-05-29 17:14:05 +02:00
|
|
|
}
|
2011-09-12 13:57:37 +02:00
|
|
|
if (strcmp(option, "auto") != 0) {
|
2014-07-25 11:56:29 +02:00
|
|
|
errno = 0;
|
|
|
|
icount_time_shift = strtol(option, &rem_str, 0);
|
|
|
|
if (errno != 0 || *rem_str != '\0' || !strlen(option)) {
|
|
|
|
error_setg(errp, "icount: Invalid shift value");
|
|
|
|
}
|
2011-09-12 13:57:37 +02:00
|
|
|
use_icount = 1;
|
|
|
|
return;
|
2014-07-25 11:56:29 +02:00
|
|
|
} else if (icount_align_option) {
|
|
|
|
error_setg(errp, "shift=auto and align=on are incompatible");
|
2015-05-29 17:14:05 +02:00
|
|
|
} else if (!icount_sleep) {
|
2016-02-26 16:16:51 +01:00
|
|
|
error_setg(errp, "shift=auto and sleep=off are incompatible");
|
2011-09-12 13:57:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
use_icount = 2;
|
|
|
|
|
|
|
|
/* 125MIPS seems a reasonable initial guess at the guest speed.
|
|
|
|
It will be corrected fairly quickly anyway. */
|
|
|
|
icount_time_shift = 3;
|
|
|
|
|
|
|
|
/* Have both realtime and virtual time triggers for speed adjustment.
|
|
|
|
The realtime trigger catches emulated time passing too slowly,
|
|
|
|
the virtual time trigger catches emulated time passing too fast.
|
|
|
|
Realtime triggers occur even when idle, so use them less frequently
|
|
|
|
than VM triggers. */
|
2018-01-11 09:26:10 +01:00
|
|
|
timers_state.vm_clock_warp_start = -1;
|
|
|
|
timers_state.icount_rt_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL_RT,
|
2014-11-26 11:40:55 +01:00
|
|
|
icount_adjust_rt, NULL);
|
2018-01-11 09:26:10 +01:00
|
|
|
timer_mod(timers_state.icount_rt_timer,
|
2014-11-26 11:40:55 +01:00
|
|
|
qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT) + 1000);
|
2018-01-11 09:26:10 +01:00
|
|
|
timers_state.icount_vm_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
|
2013-08-21 17:03:02 +02:00
|
|
|
icount_adjust_vm, NULL);
|
2018-01-11 09:26:10 +01:00
|
|
|
timer_mod(timers_state.icount_vm_timer,
|
2013-08-21 17:03:02 +02:00
|
|
|
qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
|
2016-03-21 17:02:30 +01:00
|
|
|
NANOSECONDS_PER_SECOND / 10);
|
2011-09-12 13:57:37 +02:00
|
|
|
}
|
|
|
|
|
2017-02-23 19:29:09 +01:00
|
|
|
/***********************************************************/
|
|
|
|
/* TCG vCPU kick timer
|
|
|
|
*
|
|
|
|
* The kick timer is responsible for moving single threaded vCPU
|
|
|
|
* emulation on to the next vCPU. If more than one vCPU is running a
|
|
|
|
* timer event with force a cpu->exit so the next vCPU can get
|
|
|
|
* scheduled.
|
|
|
|
*
|
|
|
|
* The timer is removed if all vCPUs are idle and restarted again once
|
|
|
|
* idleness is complete.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static QEMUTimer *tcg_kick_vcpu_timer;
|
2017-02-23 19:29:10 +01:00
|
|
|
static CPUState *tcg_current_rr_cpu;
|
2017-02-23 19:29:09 +01:00
|
|
|
|
|
|
|
#define TCG_KICK_PERIOD (NANOSECONDS_PER_SECOND / 10)
|
|
|
|
|
|
|
|
static inline int64_t qemu_tcg_next_kick(void)
|
|
|
|
{
|
|
|
|
return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + TCG_KICK_PERIOD;
|
|
|
|
}
|
|
|
|
|
2017-02-23 19:29:10 +01:00
|
|
|
/* Kick the currently round-robin scheduled vCPU */
|
|
|
|
static void qemu_cpu_kick_rr_cpu(void)
|
|
|
|
{
|
|
|
|
CPUState *cpu;
|
|
|
|
do {
|
|
|
|
cpu = atomic_mb_read(&tcg_current_rr_cpu);
|
|
|
|
if (cpu) {
|
|
|
|
cpu_exit(cpu);
|
|
|
|
}
|
|
|
|
} while (cpu != atomic_mb_read(&tcg_current_rr_cpu));
|
|
|
|
}
|
|
|
|
|
2017-03-02 19:56:40 +01:00
|
|
|
static void do_nothing(CPUState *cpu, run_on_cpu_data unused)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2017-03-03 11:50:29 +01:00
|
|
|
void qemu_timer_notify_cb(void *opaque, QEMUClockType type)
|
|
|
|
{
|
2017-03-02 19:56:40 +01:00
|
|
|
if (!use_icount || type != QEMU_CLOCK_VIRTUAL) {
|
|
|
|
qemu_notify_event();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-04-10 14:02:25 +02:00
|
|
|
if (qemu_in_vcpu_thread()) {
|
|
|
|
/* A CPU is currently running; kick it back out to the
|
|
|
|
* tcg_cpu_exec() loop so it will recalculate its
|
|
|
|
* icount deadline immediately.
|
|
|
|
*/
|
|
|
|
qemu_cpu_kick(current_cpu);
|
|
|
|
} else if (first_cpu) {
|
2017-03-02 19:56:40 +01:00
|
|
|
/* qemu_cpu_kick is not enough to kick a halted CPU out of
|
|
|
|
* qemu_tcg_wait_io_event. async_run_on_cpu, instead,
|
|
|
|
* causes cpu_thread_is_idle to return false. This way,
|
|
|
|
* handle_icount_deadline can run.
|
2018-04-10 14:02:25 +02:00
|
|
|
* If we have no CPUs at all for some reason, we don't
|
|
|
|
* need to do anything.
|
2017-03-02 19:56:40 +01:00
|
|
|
*/
|
|
|
|
async_run_on_cpu(first_cpu, do_nothing, RUN_ON_CPU_NULL);
|
|
|
|
}
|
2017-03-03 11:50:29 +01:00
|
|
|
}
|
|
|
|
|
2017-02-23 19:29:09 +01:00
|
|
|
static void kick_tcg_thread(void *opaque)
|
|
|
|
{
|
|
|
|
timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
|
2017-02-23 19:29:10 +01:00
|
|
|
qemu_cpu_kick_rr_cpu();
|
2017-02-23 19:29:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void start_tcg_kick_timer(void)
|
|
|
|
{
|
2018-01-11 13:53:12 +01:00
|
|
|
assert(!mttcg_enabled);
|
|
|
|
if (!tcg_kick_vcpu_timer && CPU_NEXT(first_cpu)) {
|
2017-02-23 19:29:09 +01:00
|
|
|
tcg_kick_vcpu_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
|
|
|
|
kick_tcg_thread, NULL);
|
|
|
|
timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void stop_tcg_kick_timer(void)
|
|
|
|
{
|
2018-01-11 13:53:12 +01:00
|
|
|
assert(!mttcg_enabled);
|
2017-02-23 19:29:09 +01:00
|
|
|
if (tcg_kick_vcpu_timer) {
|
|
|
|
timer_del(tcg_kick_vcpu_timer);
|
|
|
|
tcg_kick_vcpu_timer = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-29 21:23:50 +02:00
|
|
|
/***********************************************************/
|
|
|
|
void hw_error(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
2012-12-17 06:18:02 +01:00
|
|
|
CPUState *cpu;
|
2010-03-29 21:23:50 +02:00
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
fprintf(stderr, "qemu: hardware error: ");
|
|
|
|
vfprintf(stderr, fmt, ap);
|
|
|
|
fprintf(stderr, "\n");
|
2013-06-24 23:50:24 +02:00
|
|
|
CPU_FOREACH(cpu) {
|
2012-12-17 06:18:02 +01:00
|
|
|
fprintf(stderr, "CPU #%d:\n", cpu->cpu_index);
|
2013-05-27 01:33:50 +02:00
|
|
|
cpu_dump_state(cpu, stderr, fprintf, CPU_DUMP_FPU);
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
va_end(ap);
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
void cpu_synchronize_all_states(void)
|
|
|
|
{
|
2013-05-29 22:29:20 +02:00
|
|
|
CPUState *cpu;
|
2010-03-29 21:23:50 +02:00
|
|
|
|
2013-06-24 23:50:24 +02:00
|
|
|
CPU_FOREACH(cpu) {
|
2013-05-29 22:29:20 +02:00
|
|
|
cpu_synchronize_state(cpu);
|
i386: hvf: add code base from Google's QEMU repository
This file begins tracking the files that will be the code base for HVF
support in QEMU. This code base is part of Google's QEMU version of
their Android emulator, and can be found at
https://android.googlesource.com/platform/external/qemu/+/emu-master-dev
This code is based on Veertu Inc's vdhh (Veertu Desktop Hosted
Hypervisor), found at https://github.com/veertuinc/vdhh. Everything is
appropriately licensed under GPL v2-or-later, except for the code inside
x86_task.c and x86_task.h, which, deriving from KVM (the Linux kernel),
is licensed GPL v2-only.
This code base already implements a very great deal of functionality,
although Google's version removed from Vertuu's the support for APIC
page and hyperv-related stuff. According to the Android Emulator Release
Notes, Revision 26.1.3 (August 2017), "Hypervisor.framework is now
enabled by default on macOS for 32-bit x86 images to improve performance
and macOS compatibility", although we better use with caution for, as the
same Revision warns us, "If you experience issues with it specifically,
please file a bug report...". The code hasn't seen much update in the
last 5 months, so I think that we can further develop the code with
occasional visiting Google's repository to see if there has been any
update.
On top of Google's code, the following changes were made:
- add code to the configure script to support the --enable-hvf argument.
If the OS is Darwin, it checks for presence of HVF in the system. The
patch also adds strings related to HVF in the file qemu-options.hx.
QEMU will only support the modern syntax style '-M accel=hvf' no enable
hvf; the legacy '-enable-hvf' will not be supported.
- fix styling issues
- add glue code to cpus.c
- move HVFX86EmulatorState field to CPUX86State, changing the
the emulation functions to have a parameter with signature 'CPUX86State *'
instead of 'CPUState *' so we don't have to get the 'env'.
Signed-off-by: Sergio Andres Gomez Del Real <Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-2-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-3-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-5-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-6-Sergio.G.DelReal@gmail.com>
Message-Id: <20170905035457.3753-7-Sergio.G.DelReal@gmail.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-09-13 11:05:09 +02:00
|
|
|
/* TODO: move to cpu_synchronize_state() */
|
|
|
|
if (hvf_enabled()) {
|
|
|
|
hvf_cpu_synchronize_state(cpu);
|
|
|
|
}
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void cpu_synchronize_all_post_reset(void)
|
|
|
|
{
|
2013-05-29 22:29:20 +02:00
|
|
|
CPUState *cpu;
|
2010-03-29 21:23:50 +02:00
|
|
|
|
2013-06-24 23:50:24 +02:00
|
|
|
CPU_FOREACH(cpu) {
|
2013-05-29 22:29:20 +02:00
|
|
|
cpu_synchronize_post_reset(cpu);
|
i386: hvf: add code base from Google's QEMU repository
This file begins tracking the files that will be the code base for HVF
support in QEMU. This code base is part of Google's QEMU version of
their Android emulator, and can be found at
https://android.googlesource.com/platform/external/qemu/+/emu-master-dev
This code is based on Veertu Inc's vdhh (Veertu Desktop Hosted
Hypervisor), found at https://github.com/veertuinc/vdhh. Everything is
appropriately licensed under GPL v2-or-later, except for the code inside
x86_task.c and x86_task.h, which, deriving from KVM (the Linux kernel),
is licensed GPL v2-only.
This code base already implements a very great deal of functionality,
although Google's version removed from Vertuu's the support for APIC
page and hyperv-related stuff. According to the Android Emulator Release
Notes, Revision 26.1.3 (August 2017), "Hypervisor.framework is now
enabled by default on macOS for 32-bit x86 images to improve performance
and macOS compatibility", although we better use with caution for, as the
same Revision warns us, "If you experience issues with it specifically,
please file a bug report...". The code hasn't seen much update in the
last 5 months, so I think that we can further develop the code with
occasional visiting Google's repository to see if there has been any
update.
On top of Google's code, the following changes were made:
- add code to the configure script to support the --enable-hvf argument.
If the OS is Darwin, it checks for presence of HVF in the system. The
patch also adds strings related to HVF in the file qemu-options.hx.
QEMU will only support the modern syntax style '-M accel=hvf' no enable
hvf; the legacy '-enable-hvf' will not be supported.
- fix styling issues
- add glue code to cpus.c
- move HVFX86EmulatorState field to CPUX86State, changing the
the emulation functions to have a parameter with signature 'CPUX86State *'
instead of 'CPUState *' so we don't have to get the 'env'.
Signed-off-by: Sergio Andres Gomez Del Real <Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-2-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-3-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-5-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-6-Sergio.G.DelReal@gmail.com>
Message-Id: <20170905035457.3753-7-Sergio.G.DelReal@gmail.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-09-13 11:05:09 +02:00
|
|
|
/* TODO: move to cpu_synchronize_post_reset() */
|
|
|
|
if (hvf_enabled()) {
|
|
|
|
hvf_cpu_synchronize_post_reset(cpu);
|
|
|
|
}
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void cpu_synchronize_all_post_init(void)
|
|
|
|
{
|
2013-05-29 22:29:20 +02:00
|
|
|
CPUState *cpu;
|
2010-03-29 21:23:50 +02:00
|
|
|
|
2013-06-24 23:50:24 +02:00
|
|
|
CPU_FOREACH(cpu) {
|
2013-05-29 22:29:20 +02:00
|
|
|
cpu_synchronize_post_init(cpu);
|
i386: hvf: add code base from Google's QEMU repository
This file begins tracking the files that will be the code base for HVF
support in QEMU. This code base is part of Google's QEMU version of
their Android emulator, and can be found at
https://android.googlesource.com/platform/external/qemu/+/emu-master-dev
This code is based on Veertu Inc's vdhh (Veertu Desktop Hosted
Hypervisor), found at https://github.com/veertuinc/vdhh. Everything is
appropriately licensed under GPL v2-or-later, except for the code inside
x86_task.c and x86_task.h, which, deriving from KVM (the Linux kernel),
is licensed GPL v2-only.
This code base already implements a very great deal of functionality,
although Google's version removed from Vertuu's the support for APIC
page and hyperv-related stuff. According to the Android Emulator Release
Notes, Revision 26.1.3 (August 2017), "Hypervisor.framework is now
enabled by default on macOS for 32-bit x86 images to improve performance
and macOS compatibility", although we better use with caution for, as the
same Revision warns us, "If you experience issues with it specifically,
please file a bug report...". The code hasn't seen much update in the
last 5 months, so I think that we can further develop the code with
occasional visiting Google's repository to see if there has been any
update.
On top of Google's code, the following changes were made:
- add code to the configure script to support the --enable-hvf argument.
If the OS is Darwin, it checks for presence of HVF in the system. The
patch also adds strings related to HVF in the file qemu-options.hx.
QEMU will only support the modern syntax style '-M accel=hvf' no enable
hvf; the legacy '-enable-hvf' will not be supported.
- fix styling issues
- add glue code to cpus.c
- move HVFX86EmulatorState field to CPUX86State, changing the
the emulation functions to have a parameter with signature 'CPUX86State *'
instead of 'CPUState *' so we don't have to get the 'env'.
Signed-off-by: Sergio Andres Gomez Del Real <Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-2-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-3-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-5-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-6-Sergio.G.DelReal@gmail.com>
Message-Id: <20170905035457.3753-7-Sergio.G.DelReal@gmail.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-09-13 11:05:09 +02:00
|
|
|
/* TODO: move to cpu_synchronize_post_init() */
|
|
|
|
if (hvf_enabled()) {
|
|
|
|
hvf_cpu_synchronize_post_init(cpu);
|
|
|
|
}
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-26 06:46:28 +02:00
|
|
|
void cpu_synchronize_all_pre_loadvm(void)
|
|
|
|
{
|
|
|
|
CPUState *cpu;
|
|
|
|
|
|
|
|
CPU_FOREACH(cpu) {
|
|
|
|
cpu_synchronize_pre_loadvm(cpu);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-07 15:42:05 +01:00
|
|
|
static int do_vm_stop(RunState state, bool send_stop)
|
2010-03-29 21:23:50 +02:00
|
|
|
{
|
2013-07-05 13:49:54 +02:00
|
|
|
int ret = 0;
|
|
|
|
|
2011-07-29 20:36:43 +02:00
|
|
|
if (runstate_is_running()) {
|
2010-03-29 21:23:50 +02:00
|
|
|
cpu_disable_ticks();
|
|
|
|
pause_all_vcpus();
|
2011-07-29 20:04:45 +02:00
|
|
|
runstate_set(state);
|
2011-07-29 19:26:33 +02:00
|
|
|
vm_state_notify(0, state);
|
2018-03-07 15:42:05 +01:00
|
|
|
if (send_stop) {
|
|
|
|
qapi_event_send_stop(&error_abort);
|
|
|
|
}
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
2013-07-05 13:49:54 +02:00
|
|
|
|
2013-07-18 14:52:19 +02:00
|
|
|
bdrv_drain_all();
|
2016-09-26 10:08:16 +02:00
|
|
|
replay_disable_events();
|
2016-09-23 03:45:51 +02:00
|
|
|
ret = bdrv_flush_all();
|
2013-07-18 14:52:19 +02:00
|
|
|
|
2013-07-05 13:49:54 +02:00
|
|
|
return ret;
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
|
2018-03-07 15:42:05 +01:00
|
|
|
/* Special vm_stop() variant for terminating the process. Historically clients
|
|
|
|
* did not expect a QMP STOP event and so we need to retain compatibility.
|
|
|
|
*/
|
|
|
|
int vm_shutdown(void)
|
|
|
|
{
|
|
|
|
return do_vm_stop(RUN_STATE_SHUTDOWN, false);
|
|
|
|
}
|
|
|
|
|
2012-05-02 23:42:26 +02:00
|
|
|
static bool cpu_can_run(CPUState *cpu)
|
2010-03-29 21:23:50 +02:00
|
|
|
{
|
2012-05-02 23:10:09 +02:00
|
|
|
if (cpu->stop) {
|
2012-05-02 23:42:26 +02:00
|
|
|
return false;
|
2011-02-07 12:19:14 +01:00
|
|
|
}
|
2013-08-02 03:43:09 +02:00
|
|
|
if (cpu_is_stopped(cpu)) {
|
2012-05-02 23:42:26 +02:00
|
|
|
return false;
|
2011-02-07 12:19:14 +01:00
|
|
|
}
|
2012-05-02 23:42:26 +02:00
|
|
|
return true;
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
|
2013-05-27 02:07:49 +02:00
|
|
|
static void cpu_handle_guest_debug(CPUState *cpu)
|
2011-02-07 12:19:17 +01:00
|
|
|
{
|
2013-05-27 02:06:09 +02:00
|
|
|
gdb_set_stop_cpu(cpu);
|
2011-02-07 12:19:16 +01:00
|
|
|
qemu_system_debug_request();
|
2012-05-02 23:26:21 +02:00
|
|
|
cpu->stopped = true;
|
2010-06-25 16:56:56 +02:00
|
|
|
}
|
|
|
|
|
2011-02-01 22:15:58 +01:00
|
|
|
#ifdef CONFIG_LINUX
|
|
|
|
static void sigbus_reraise(void)
|
|
|
|
{
|
|
|
|
sigset_t set;
|
|
|
|
struct sigaction action;
|
|
|
|
|
|
|
|
memset(&action, 0, sizeof(action));
|
|
|
|
action.sa_handler = SIG_DFL;
|
|
|
|
if (!sigaction(SIGBUS, &action, NULL)) {
|
|
|
|
raise(SIGBUS);
|
|
|
|
sigemptyset(&set);
|
|
|
|
sigaddset(&set, SIGBUS);
|
2016-05-16 19:33:59 +02:00
|
|
|
pthread_sigmask(SIG_UNBLOCK, &set, NULL);
|
2011-02-01 22:15:58 +01:00
|
|
|
}
|
|
|
|
perror("Failed to re-raise SIGBUS!\n");
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
2017-02-08 13:22:12 +01:00
|
|
|
static void sigbus_handler(int n, siginfo_t *siginfo, void *ctx)
|
2011-02-01 22:15:58 +01:00
|
|
|
{
|
2017-02-09 09:50:02 +01:00
|
|
|
if (siginfo->si_code != BUS_MCEERR_AO && siginfo->si_code != BUS_MCEERR_AR) {
|
|
|
|
sigbus_reraise();
|
|
|
|
}
|
|
|
|
|
2017-02-08 12:48:54 +01:00
|
|
|
if (current_cpu) {
|
|
|
|
/* Called asynchronously in VCPU thread. */
|
|
|
|
if (kvm_on_sigbus_vcpu(current_cpu, siginfo->si_code, siginfo->si_addr)) {
|
|
|
|
sigbus_reraise();
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Called synchronously (via signalfd) in main thread. */
|
|
|
|
if (kvm_on_sigbus(siginfo->si_code, siginfo->si_addr)) {
|
|
|
|
sigbus_reraise();
|
|
|
|
}
|
2011-02-01 22:15:58 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qemu_init_sigbus(void)
|
|
|
|
{
|
|
|
|
struct sigaction action;
|
|
|
|
|
|
|
|
memset(&action, 0, sizeof(action));
|
|
|
|
action.sa_flags = SA_SIGINFO;
|
2017-02-08 13:22:12 +01:00
|
|
|
action.sa_sigaction = sigbus_handler;
|
2011-02-01 22:15:58 +01:00
|
|
|
sigaction(SIGBUS, &action, NULL);
|
|
|
|
|
|
|
|
prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, 0, 0);
|
|
|
|
}
|
|
|
|
#else /* !CONFIG_LINUX */
|
|
|
|
static void qemu_init_sigbus(void)
|
|
|
|
{
|
|
|
|
}
|
2017-02-09 09:50:02 +01:00
|
|
|
#endif /* !CONFIG_LINUX */
|
2011-02-01 22:15:53 +01:00
|
|
|
|
2012-09-27 07:41:42 +02:00
|
|
|
static QemuMutex qemu_global_mutex;
|
2010-03-29 21:23:50 +02:00
|
|
|
|
|
|
|
static QemuThread io_thread;
|
|
|
|
|
|
|
|
/* cpu creation */
|
|
|
|
static QemuCond qemu_cpu_cond;
|
|
|
|
/* system init */
|
|
|
|
static QemuCond qemu_pause_cond;
|
|
|
|
|
2011-09-13 10:30:52 +02:00
|
|
|
void qemu_init_cpu_loop(void)
|
2010-03-29 21:23:50 +02:00
|
|
|
{
|
2011-02-01 22:15:58 +01:00
|
|
|
qemu_init_sigbus();
|
2011-02-08 18:18:18 +01:00
|
|
|
qemu_cond_init(&qemu_cpu_cond);
|
|
|
|
qemu_cond_init(&qemu_pause_cond);
|
2010-03-29 21:23:50 +02:00
|
|
|
qemu_mutex_init(&qemu_global_mutex);
|
|
|
|
|
2011-03-12 17:43:51 +01:00
|
|
|
qemu_thread_get_self(&io_thread);
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
|
2016-10-31 10:36:08 +01:00
|
|
|
void run_on_cpu(CPUState *cpu, run_on_cpu_func func, run_on_cpu_data data)
|
2010-05-04 14:45:22 +02:00
|
|
|
{
|
2016-08-29 09:51:00 +02:00
|
|
|
do_run_on_cpu(cpu, func, data, &qemu_global_mutex);
|
2013-06-24 11:49:41 +02:00
|
|
|
}
|
|
|
|
|
2016-05-12 05:48:13 +02:00
|
|
|
static void qemu_kvm_destroy_vcpu(CPUState *cpu)
|
|
|
|
{
|
|
|
|
if (kvm_destroy_vcpu(cpu) < 0) {
|
|
|
|
error_report("kvm_destroy_vcpu failed");
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qemu_tcg_destroy_vcpu(CPUState *cpu)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2017-11-29 20:12:15 +01:00
|
|
|
static void qemu_cpu_stop(CPUState *cpu, bool exit)
|
|
|
|
{
|
|
|
|
g_assert(qemu_cpu_is_self(cpu));
|
|
|
|
cpu->stop = false;
|
|
|
|
cpu->stopped = true;
|
|
|
|
if (exit) {
|
|
|
|
cpu_exit(cpu);
|
|
|
|
}
|
|
|
|
qemu_cond_broadcast(&qemu_pause_cond);
|
|
|
|
}
|
|
|
|
|
2012-05-03 02:18:09 +02:00
|
|
|
static void qemu_wait_io_event_common(CPUState *cpu)
|
2010-03-29 21:23:50 +02:00
|
|
|
{
|
2017-02-23 19:29:14 +01:00
|
|
|
atomic_mb_set(&cpu->thread_kicked, false);
|
2012-05-02 23:10:09 +02:00
|
|
|
if (cpu->stop) {
|
2017-11-29 20:12:15 +01:00
|
|
|
qemu_cpu_stop(cpu, false);
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
2016-08-02 19:27:36 +02:00
|
|
|
process_queued_cpu_work(cpu);
|
2017-02-23 19:29:14 +01:00
|
|
|
}
|
|
|
|
|
2018-01-11 13:53:12 +01:00
|
|
|
static void qemu_tcg_rr_wait_io_event(CPUState *cpu)
|
2017-02-23 19:29:14 +01:00
|
|
|
{
|
2018-01-11 13:53:12 +01:00
|
|
|
while (all_cpu_threads_idle()) {
|
2017-02-23 19:29:09 +01:00
|
|
|
stop_tcg_kick_timer();
|
2015-08-10 17:27:06 +02:00
|
|
|
qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
|
2011-02-09 16:29:37 +01:00
|
|
|
}
|
2010-03-29 21:23:50 +02:00
|
|
|
|
2017-02-23 19:29:09 +01:00
|
|
|
start_tcg_kick_timer();
|
|
|
|
|
2017-02-23 19:29:14 +01:00
|
|
|
qemu_wait_io_event_common(cpu);
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
|
2018-01-11 13:53:12 +01:00
|
|
|
static void qemu_wait_io_event(CPUState *cpu)
|
2010-03-29 21:23:50 +02:00
|
|
|
{
|
2013-05-26 23:21:08 +02:00
|
|
|
while (cpu_thread_is_idle(cpu)) {
|
2012-05-03 01:22:49 +02:00
|
|
|
qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
|
2011-02-09 16:29:37 +01:00
|
|
|
}
|
2010-03-29 21:23:50 +02:00
|
|
|
|
2018-01-11 13:53:12 +01:00
|
|
|
#ifdef _WIN32
|
|
|
|
/* Eat dummy APC queued by qemu_cpu_kick_thread. */
|
|
|
|
if (!tcg_enabled()) {
|
|
|
|
SleepEx(0, TRUE);
|
i386: hvf: add code base from Google's QEMU repository
This file begins tracking the files that will be the code base for HVF
support in QEMU. This code base is part of Google's QEMU version of
their Android emulator, and can be found at
https://android.googlesource.com/platform/external/qemu/+/emu-master-dev
This code is based on Veertu Inc's vdhh (Veertu Desktop Hosted
Hypervisor), found at https://github.com/veertuinc/vdhh. Everything is
appropriately licensed under GPL v2-or-later, except for the code inside
x86_task.c and x86_task.h, which, deriving from KVM (the Linux kernel),
is licensed GPL v2-only.
This code base already implements a very great deal of functionality,
although Google's version removed from Vertuu's the support for APIC
page and hyperv-related stuff. According to the Android Emulator Release
Notes, Revision 26.1.3 (August 2017), "Hypervisor.framework is now
enabled by default on macOS for 32-bit x86 images to improve performance
and macOS compatibility", although we better use with caution for, as the
same Revision warns us, "If you experience issues with it specifically,
please file a bug report...". The code hasn't seen much update in the
last 5 months, so I think that we can further develop the code with
occasional visiting Google's repository to see if there has been any
update.
On top of Google's code, the following changes were made:
- add code to the configure script to support the --enable-hvf argument.
If the OS is Darwin, it checks for presence of HVF in the system. The
patch also adds strings related to HVF in the file qemu-options.hx.
QEMU will only support the modern syntax style '-M accel=hvf' no enable
hvf; the legacy '-enable-hvf' will not be supported.
- fix styling issues
- add glue code to cpus.c
- move HVFX86EmulatorState field to CPUX86State, changing the
the emulation functions to have a parameter with signature 'CPUX86State *'
instead of 'CPUState *' so we don't have to get the 'env'.
Signed-off-by: Sergio Andres Gomez Del Real <Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-2-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-3-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-5-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-6-Sergio.G.DelReal@gmail.com>
Message-Id: <20170905035457.3753-7-Sergio.G.DelReal@gmail.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-09-13 11:05:09 +02:00
|
|
|
}
|
2018-01-11 13:53:12 +01:00
|
|
|
#endif
|
i386: hvf: add code base from Google's QEMU repository
This file begins tracking the files that will be the code base for HVF
support in QEMU. This code base is part of Google's QEMU version of
their Android emulator, and can be found at
https://android.googlesource.com/platform/external/qemu/+/emu-master-dev
This code is based on Veertu Inc's vdhh (Veertu Desktop Hosted
Hypervisor), found at https://github.com/veertuinc/vdhh. Everything is
appropriately licensed under GPL v2-or-later, except for the code inside
x86_task.c and x86_task.h, which, deriving from KVM (the Linux kernel),
is licensed GPL v2-only.
This code base already implements a very great deal of functionality,
although Google's version removed from Vertuu's the support for APIC
page and hyperv-related stuff. According to the Android Emulator Release
Notes, Revision 26.1.3 (August 2017), "Hypervisor.framework is now
enabled by default on macOS for 32-bit x86 images to improve performance
and macOS compatibility", although we better use with caution for, as the
same Revision warns us, "If you experience issues with it specifically,
please file a bug report...". The code hasn't seen much update in the
last 5 months, so I think that we can further develop the code with
occasional visiting Google's repository to see if there has been any
update.
On top of Google's code, the following changes were made:
- add code to the configure script to support the --enable-hvf argument.
If the OS is Darwin, it checks for presence of HVF in the system. The
patch also adds strings related to HVF in the file qemu-options.hx.
QEMU will only support the modern syntax style '-M accel=hvf' no enable
hvf; the legacy '-enable-hvf' will not be supported.
- fix styling issues
- add glue code to cpus.c
- move HVFX86EmulatorState field to CPUX86State, changing the
the emulation functions to have a parameter with signature 'CPUX86State *'
instead of 'CPUState *' so we don't have to get the 'env'.
Signed-off-by: Sergio Andres Gomez Del Real <Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-2-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-3-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-5-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-6-Sergio.G.DelReal@gmail.com>
Message-Id: <20170905035457.3753-7-Sergio.G.DelReal@gmail.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-09-13 11:05:09 +02:00
|
|
|
qemu_wait_io_event_common(cpu);
|
|
|
|
}
|
|
|
|
|
2011-02-07 12:19:12 +01:00
|
|
|
static void *qemu_kvm_cpu_thread_fn(void *arg)
|
2010-03-29 21:23:50 +02:00
|
|
|
{
|
2013-05-27 02:20:39 +02:00
|
|
|
CPUState *cpu = arg;
|
2011-02-01 22:15:50 +01:00
|
|
|
int r;
|
2010-03-29 21:23:50 +02:00
|
|
|
|
2015-07-09 08:55:38 +02:00
|
|
|
rcu_register_thread();
|
|
|
|
|
2015-06-18 18:47:18 +02:00
|
|
|
qemu_mutex_lock_iothread();
|
2012-05-02 17:00:37 +02:00
|
|
|
qemu_thread_get_self(cpu->thread);
|
2012-05-03 06:59:07 +02:00
|
|
|
cpu->thread_id = qemu_get_thread_id();
|
2014-12-08 08:53:17 +01:00
|
|
|
cpu->can_do_io = 1;
|
2013-05-27 05:17:50 +02:00
|
|
|
current_cpu = cpu;
|
2010-03-29 21:23:50 +02:00
|
|
|
|
2012-12-17 06:38:45 +01:00
|
|
|
r = kvm_init_vcpu(cpu);
|
2011-02-01 22:15:50 +01:00
|
|
|
if (r < 0) {
|
tcg: Replace fprintf(stderr, "*\n" with error_report()
Replace a large number of the fprintf(stderr, "*\n" calls with
error_report(). The functions were renamed with these commands and then
compiler issues where manually fixed.
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
Signed-off-by: Alistair Francis <alistair.francis@xilinx.com>
Cc: Paolo Bonzini <pbonzini@redhat.com>
Cc: Peter Crosthwaite <crosthwaite.peter@gmail.com>
Cc: Richard Henderson <rth@twiddle.net>
Cc: Stefan Weil <sw@weilnetz.de>
Conversions that aren't followed by exit() dropped, because they might
be inappropriate.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Message-Id: <20180203084315.20497-14-armbru@redhat.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
2018-02-03 09:43:14 +01:00
|
|
|
error_report("kvm_init_vcpu failed: %s", strerror(-r));
|
2011-02-01 22:15:50 +01:00
|
|
|
exit(1);
|
|
|
|
}
|
2010-03-29 21:23:50 +02:00
|
|
|
|
2017-02-09 09:41:14 +01:00
|
|
|
kvm_init_cpu_signals(cpu);
|
2010-03-29 21:23:50 +02:00
|
|
|
|
|
|
|
/* signal CPU creation */
|
2012-05-02 22:49:36 +02:00
|
|
|
cpu->created = true;
|
2010-03-29 21:23:50 +02:00
|
|
|
qemu_cond_signal(&qemu_cpu_cond);
|
|
|
|
|
2016-05-12 05:48:13 +02:00
|
|
|
do {
|
2012-05-02 23:42:26 +02:00
|
|
|
if (cpu_can_run(cpu)) {
|
2013-05-26 23:46:55 +02:00
|
|
|
r = kvm_cpu_exec(cpu);
|
2011-02-07 12:19:17 +01:00
|
|
|
if (r == EXCP_DEBUG) {
|
2013-05-27 02:07:49 +02:00
|
|
|
cpu_handle_guest_debug(cpu);
|
2011-02-07 12:19:17 +01:00
|
|
|
}
|
2011-02-07 12:19:14 +01:00
|
|
|
}
|
2018-01-11 13:53:12 +01:00
|
|
|
qemu_wait_io_event(cpu);
|
2016-05-12 05:48:13 +02:00
|
|
|
} while (!cpu->unplug || cpu_can_run(cpu));
|
2010-03-29 21:23:50 +02:00
|
|
|
|
2016-05-12 05:48:13 +02:00
|
|
|
qemu_kvm_destroy_vcpu(cpu);
|
2016-05-12 05:48:14 +02:00
|
|
|
cpu->created = false;
|
|
|
|
qemu_cond_signal(&qemu_cpu_cond);
|
2016-05-12 05:48:13 +02:00
|
|
|
qemu_mutex_unlock_iothread();
|
2018-01-30 17:04:36 +01:00
|
|
|
rcu_unregister_thread();
|
2010-03-29 21:23:50 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-03-28 15:42:02 +02:00
|
|
|
static void *qemu_dummy_cpu_thread_fn(void *arg)
|
|
|
|
{
|
|
|
|
#ifdef _WIN32
|
tcg: Replace fprintf(stderr, "*\n" with error_report()
Replace a large number of the fprintf(stderr, "*\n" calls with
error_report(). The functions were renamed with these commands and then
compiler issues where manually fixed.
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
Signed-off-by: Alistair Francis <alistair.francis@xilinx.com>
Cc: Paolo Bonzini <pbonzini@redhat.com>
Cc: Peter Crosthwaite <crosthwaite.peter@gmail.com>
Cc: Richard Henderson <rth@twiddle.net>
Cc: Stefan Weil <sw@weilnetz.de>
Conversions that aren't followed by exit() dropped, because they might
be inappropriate.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Message-Id: <20180203084315.20497-14-armbru@redhat.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
2018-02-03 09:43:14 +01:00
|
|
|
error_report("qtest is not supported under Windows");
|
2012-03-28 15:42:02 +02:00
|
|
|
exit(1);
|
|
|
|
#else
|
2013-05-27 02:24:35 +02:00
|
|
|
CPUState *cpu = arg;
|
2012-03-28 15:42:02 +02:00
|
|
|
sigset_t waitset;
|
|
|
|
int r;
|
|
|
|
|
2015-07-09 08:55:38 +02:00
|
|
|
rcu_register_thread();
|
|
|
|
|
2012-03-28 15:42:02 +02:00
|
|
|
qemu_mutex_lock_iothread();
|
2012-05-02 17:00:37 +02:00
|
|
|
qemu_thread_get_self(cpu->thread);
|
2012-05-03 06:59:07 +02:00
|
|
|
cpu->thread_id = qemu_get_thread_id();
|
2014-12-08 08:53:17 +01:00
|
|
|
cpu->can_do_io = 1;
|
2017-02-23 19:29:14 +01:00
|
|
|
current_cpu = cpu;
|
2012-03-28 15:42:02 +02:00
|
|
|
|
|
|
|
sigemptyset(&waitset);
|
|
|
|
sigaddset(&waitset, SIG_IPI);
|
|
|
|
|
|
|
|
/* signal CPU creation */
|
2012-05-02 22:49:36 +02:00
|
|
|
cpu->created = true;
|
2012-03-28 15:42:02 +02:00
|
|
|
qemu_cond_signal(&qemu_cpu_cond);
|
|
|
|
|
2018-01-30 17:04:53 +01:00
|
|
|
do {
|
2012-03-28 15:42:02 +02:00
|
|
|
qemu_mutex_unlock_iothread();
|
|
|
|
do {
|
|
|
|
int sig;
|
|
|
|
r = sigwait(&waitset, &sig);
|
|
|
|
} while (r == -1 && (errno == EAGAIN || errno == EINTR));
|
|
|
|
if (r == -1) {
|
|
|
|
perror("sigwait");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
qemu_mutex_lock_iothread();
|
2018-01-11 13:53:12 +01:00
|
|
|
qemu_wait_io_event(cpu);
|
2018-01-30 17:04:53 +01:00
|
|
|
} while (!cpu->unplug);
|
2012-03-28 15:42:02 +02:00
|
|
|
|
2018-01-30 17:04:53 +01:00
|
|
|
rcu_unregister_thread();
|
2012-03-28 15:42:02 +02:00
|
|
|
return NULL;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2016-10-27 17:10:08 +02:00
|
|
|
static int64_t tcg_get_icount_limit(void)
|
|
|
|
{
|
|
|
|
int64_t deadline;
|
|
|
|
|
|
|
|
if (replay_mode != REPLAY_MODE_PLAY) {
|
|
|
|
deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
|
|
|
|
|
|
|
|
/* Maintain prior (possibly buggy) behaviour where if no deadline
|
|
|
|
* was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than
|
|
|
|
* INT32_MAX nanoseconds ahead, we still use INT32_MAX
|
|
|
|
* nanoseconds.
|
|
|
|
*/
|
|
|
|
if ((deadline < 0) || (deadline > INT32_MAX)) {
|
|
|
|
deadline = INT32_MAX;
|
|
|
|
}
|
|
|
|
|
|
|
|
return qemu_icount_round(deadline);
|
|
|
|
} else {
|
|
|
|
return replay_get_instructions();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-27 17:10:14 +02:00
|
|
|
static void handle_icount_deadline(void)
|
|
|
|
{
|
2017-03-02 19:56:40 +01:00
|
|
|
assert(qemu_in_vcpu_thread());
|
2016-10-27 17:10:14 +02:00
|
|
|
if (use_icount) {
|
|
|
|
int64_t deadline =
|
|
|
|
qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
|
|
|
|
|
|
|
|
if (deadline == 0) {
|
2017-03-02 19:56:40 +01:00
|
|
|
/* Wake up other AioContexts. */
|
2016-10-27 17:10:14 +02:00
|
|
|
qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
|
2017-03-02 19:56:40 +01:00
|
|
|
qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
|
2016-10-27 17:10:14 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-29 17:46:59 +02:00
|
|
|
static void prepare_icount_for_run(CPUState *cpu)
|
2016-10-27 17:10:08 +02:00
|
|
|
{
|
|
|
|
if (use_icount) {
|
2017-04-05 13:35:48 +02:00
|
|
|
int insns_left;
|
2017-03-29 17:46:59 +02:00
|
|
|
|
|
|
|
/* These should always be cleared by process_icount_data after
|
|
|
|
* each vCPU execution. However u16.high can be raised
|
|
|
|
* asynchronously by cpu_exit/cpu_interrupt/tcg_handle_interrupt
|
|
|
|
*/
|
|
|
|
g_assert(cpu->icount_decr.u16.low == 0);
|
|
|
|
g_assert(cpu->icount_extra == 0);
|
|
|
|
|
2017-04-05 13:35:48 +02:00
|
|
|
cpu->icount_budget = tcg_get_icount_limit();
|
|
|
|
insns_left = MIN(0xffff, cpu->icount_budget);
|
|
|
|
cpu->icount_decr.u16.low = insns_left;
|
|
|
|
cpu->icount_extra = cpu->icount_budget - insns_left;
|
2018-02-27 10:52:48 +01:00
|
|
|
|
|
|
|
replay_mutex_lock();
|
2016-10-27 17:10:08 +02:00
|
|
|
}
|
2017-03-29 17:46:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void process_icount_data(CPUState *cpu)
|
|
|
|
{
|
2016-10-27 17:10:08 +02:00
|
|
|
if (use_icount) {
|
2017-03-31 17:09:42 +02:00
|
|
|
/* Account for executed instructions */
|
2017-04-05 13:32:37 +02:00
|
|
|
cpu_update_icount(cpu);
|
2017-03-29 17:46:59 +02:00
|
|
|
|
|
|
|
/* Reset the counters */
|
|
|
|
cpu->icount_decr.u16.low = 0;
|
2016-10-27 17:10:08 +02:00
|
|
|
cpu->icount_extra = 0;
|
2017-03-31 17:09:42 +02:00
|
|
|
cpu->icount_budget = 0;
|
|
|
|
|
2016-10-27 17:10:08 +02:00
|
|
|
replay_account_executed_instructions();
|
2018-02-27 10:52:48 +01:00
|
|
|
|
|
|
|
replay_mutex_unlock();
|
2016-10-27 17:10:08 +02:00
|
|
|
}
|
2017-03-29 17:46:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int tcg_cpu_exec(CPUState *cpu)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
#ifdef CONFIG_PROFILER
|
|
|
|
int64_t ti;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_PROFILER
|
|
|
|
ti = profile_getclock();
|
|
|
|
#endif
|
|
|
|
cpu_exec_start(cpu);
|
|
|
|
ret = cpu_exec(cpu);
|
|
|
|
cpu_exec_end(cpu);
|
|
|
|
#ifdef CONFIG_PROFILER
|
|
|
|
tcg_time += profile_getclock() - ti;
|
|
|
|
#endif
|
2016-10-27 17:10:08 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-10-27 17:10:09 +02:00
|
|
|
/* Destroy any remaining vCPUs which have been unplugged and have
|
|
|
|
* finished running
|
|
|
|
*/
|
|
|
|
static void deal_with_unplugged_cpus(void)
|
2016-10-27 17:10:08 +02:00
|
|
|
{
|
2016-10-27 17:10:09 +02:00
|
|
|
CPUState *cpu;
|
2016-10-27 17:10:08 +02:00
|
|
|
|
2016-10-27 17:10:09 +02:00
|
|
|
CPU_FOREACH(cpu) {
|
|
|
|
if (cpu->unplug && !cpu_can_run(cpu)) {
|
|
|
|
qemu_tcg_destroy_vcpu(cpu);
|
|
|
|
cpu->created = false;
|
|
|
|
qemu_cond_signal(&qemu_cpu_cond);
|
2016-10-27 17:10:08 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-09-26 09:40:39 +02:00
|
|
|
|
2017-02-23 19:29:09 +01:00
|
|
|
/* Single-threaded TCG
|
|
|
|
*
|
|
|
|
* In the single-threaded case each vCPU is simulated in turn. If
|
|
|
|
* there is more than a single vCPU we create a simple timer to kick
|
|
|
|
* the vCPU and ensure we don't get stuck in a tight loop in one vCPU.
|
|
|
|
* This is done explicitly rather than relying on side-effects
|
|
|
|
* elsewhere.
|
|
|
|
*/
|
|
|
|
|
2017-02-23 19:29:14 +01:00
|
|
|
static void *qemu_tcg_rr_cpu_thread_fn(void *arg)
|
2010-03-29 21:23:50 +02:00
|
|
|
{
|
2012-05-03 01:41:24 +02:00
|
|
|
CPUState *cpu = arg;
|
2010-03-29 21:23:50 +02:00
|
|
|
|
2015-07-09 08:55:38 +02:00
|
|
|
rcu_register_thread();
|
tcg: enable multiple TCG contexts in softmmu
This enables parallel TCG code generation. However, we do not take
advantage of it yet since tb_lock is still held during tb_gen_code.
In user-mode we use a single TCG context; see the documentation
added to tcg_region_init for the rationale.
Note that targets do not need any conversion: targets initialize a
TCGContext (e.g. defining TCG globals), and after this initialization
has finished, the context is cloned by the vCPU threads, each of
them keeping a separate copy.
TCG threads claim one entry in tcg_ctxs[] by atomically increasing
n_tcg_ctxs. Do not be too annoyed by the subsequent atomic_read's
of that variable and tcg_ctxs; they are there just to play nice with
analysis tools such as thread sanitizer.
Note that we do not allocate an array of contexts (we allocate
an array of pointers instead) because when tcg_context_init
is called, we do not know yet how many contexts we'll use since
the bool behind qemu_tcg_mttcg_enabled() isn't set yet.
Previous patches folded some TCG globals into TCGContext. The non-const
globals remaining are only set at init time, i.e. before the TCG
threads are spawned. Here is a list of these set-at-init-time globals
under tcg/:
Only written by tcg_context_init:
- indirect_reg_alloc_order
- tcg_op_defs
Only written by tcg_target_init (called from tcg_context_init):
- tcg_target_available_regs
- tcg_target_call_clobber_regs
- arm: arm_arch, use_idiv_instructions
- i386: have_cmov, have_bmi1, have_bmi2, have_lzcnt,
have_movbe, have_popcnt
- mips: use_movnz_instructions, use_mips32_instructions,
use_mips32r2_instructions, got_sigill (tcg_target_detect_isa)
- ppc: have_isa_2_06, have_isa_3_00, tb_ret_addr
- s390: tb_ret_addr, s390_facilities
- sparc: qemu_ld_trampoline, qemu_st_trampoline (build_trampolines),
use_vis3_instructions
Only written by tcg_prologue_init:
- 'struct jit_code_entry one_entry'
- aarch64: tb_ret_addr
- arm: tb_ret_addr
- i386: tb_ret_addr, guest_base_flags
- ia64: tb_ret_addr
- mips: tb_ret_addr, bswap32_addr, bswap32u_addr, bswap64_addr
Reviewed-by: Richard Henderson <rth@twiddle.net>
Signed-off-by: Emilio G. Cota <cota@braap.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
2017-07-20 00:57:58 +02:00
|
|
|
tcg_register_thread();
|
2015-07-09 08:55:38 +02:00
|
|
|
|
2015-06-18 18:47:18 +02:00
|
|
|
qemu_mutex_lock_iothread();
|
2012-05-02 17:00:37 +02:00
|
|
|
qemu_thread_get_self(cpu->thread);
|
2010-03-29 21:23:50 +02:00
|
|
|
|
2018-02-09 20:52:39 +01:00
|
|
|
cpu->thread_id = qemu_get_thread_id();
|
|
|
|
cpu->created = true;
|
|
|
|
cpu->can_do_io = 1;
|
2010-03-29 21:23:50 +02:00
|
|
|
qemu_cond_signal(&qemu_cpu_cond);
|
|
|
|
|
2011-08-22 18:35:25 +02:00
|
|
|
/* wait for initial kick-off after machine start */
|
2015-04-27 18:45:28 +02:00
|
|
|
while (first_cpu->stopped) {
|
2015-08-10 17:27:06 +02:00
|
|
|
qemu_cond_wait(first_cpu->halt_cond, &qemu_global_mutex);
|
2012-02-17 18:31:15 +01:00
|
|
|
|
|
|
|
/* process any pending work */
|
2013-06-24 23:50:24 +02:00
|
|
|
CPU_FOREACH(cpu) {
|
2017-02-23 19:29:14 +01:00
|
|
|
current_cpu = cpu;
|
2013-05-29 22:29:20 +02:00
|
|
|
qemu_wait_io_event_common(cpu);
|
2012-02-17 18:31:15 +01:00
|
|
|
}
|
2011-02-07 12:19:14 +01:00
|
|
|
}
|
2010-03-29 21:23:50 +02:00
|
|
|
|
2017-02-23 19:29:09 +01:00
|
|
|
start_tcg_kick_timer();
|
|
|
|
|
2016-10-27 17:10:09 +02:00
|
|
|
cpu = first_cpu;
|
|
|
|
|
2017-02-23 19:29:12 +01:00
|
|
|
/* process any pending work */
|
|
|
|
cpu->exit_request = 1;
|
|
|
|
|
2010-03-29 21:23:50 +02:00
|
|
|
while (1) {
|
2018-02-27 10:52:48 +01:00
|
|
|
qemu_mutex_unlock_iothread();
|
|
|
|
replay_mutex_lock();
|
|
|
|
qemu_mutex_lock_iothread();
|
2016-10-27 17:10:09 +02:00
|
|
|
/* Account partial waits to QEMU_CLOCK_VIRTUAL. */
|
|
|
|
qemu_account_warp_timer();
|
|
|
|
|
2017-03-02 19:56:40 +01:00
|
|
|
/* Run the timers here. This is much more efficient than
|
|
|
|
* waking up the I/O thread and waiting for completion.
|
|
|
|
*/
|
|
|
|
handle_icount_deadline();
|
|
|
|
|
2018-02-27 10:52:48 +01:00
|
|
|
replay_mutex_unlock();
|
|
|
|
|
2016-10-27 17:10:09 +02:00
|
|
|
if (!cpu) {
|
|
|
|
cpu = first_cpu;
|
|
|
|
}
|
|
|
|
|
2017-02-23 19:29:12 +01:00
|
|
|
while (cpu && !cpu->queued_work_first && !cpu->exit_request) {
|
|
|
|
|
2017-02-23 19:29:10 +01:00
|
|
|
atomic_mb_set(&tcg_current_rr_cpu, cpu);
|
2017-02-23 19:29:14 +01:00
|
|
|
current_cpu = cpu;
|
2016-10-27 17:10:09 +02:00
|
|
|
|
|
|
|
qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
|
|
|
|
(cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);
|
|
|
|
|
|
|
|
if (cpu_can_run(cpu)) {
|
|
|
|
int r;
|
2017-03-29 17:46:59 +02:00
|
|
|
|
2018-02-27 10:52:48 +01:00
|
|
|
qemu_mutex_unlock_iothread();
|
2017-03-29 17:46:59 +02:00
|
|
|
prepare_icount_for_run(cpu);
|
|
|
|
|
2016-10-27 17:10:09 +02:00
|
|
|
r = tcg_cpu_exec(cpu);
|
2017-03-29 17:46:59 +02:00
|
|
|
|
|
|
|
process_icount_data(cpu);
|
2018-02-27 10:52:48 +01:00
|
|
|
qemu_mutex_lock_iothread();
|
2017-03-29 17:46:59 +02:00
|
|
|
|
2016-10-27 17:10:09 +02:00
|
|
|
if (r == EXCP_DEBUG) {
|
|
|
|
cpu_handle_guest_debug(cpu);
|
|
|
|
break;
|
2017-02-23 19:29:15 +01:00
|
|
|
} else if (r == EXCP_ATOMIC) {
|
|
|
|
qemu_mutex_unlock_iothread();
|
|
|
|
cpu_exec_step_atomic(cpu);
|
|
|
|
qemu_mutex_lock_iothread();
|
|
|
|
break;
|
2016-10-27 17:10:09 +02:00
|
|
|
}
|
2017-02-23 19:29:14 +01:00
|
|
|
} else if (cpu->stop) {
|
2016-10-27 17:10:09 +02:00
|
|
|
if (cpu->unplug) {
|
|
|
|
cpu = CPU_NEXT(cpu);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2017-02-23 19:29:12 +01:00
|
|
|
cpu = CPU_NEXT(cpu);
|
|
|
|
} /* while (cpu && !cpu->exit_request).. */
|
|
|
|
|
2017-02-23 19:29:10 +01:00
|
|
|
/* Does not need atomic_mb_set because a spurious wakeup is okay. */
|
|
|
|
atomic_set(&tcg_current_rr_cpu, NULL);
|
2016-10-27 17:10:09 +02:00
|
|
|
|
2017-02-23 19:29:12 +01:00
|
|
|
if (cpu && cpu->exit_request) {
|
|
|
|
atomic_mb_set(&cpu->exit_request, 0);
|
|
|
|
}
|
2013-08-21 17:02:57 +02:00
|
|
|
|
2018-01-11 13:53:12 +01:00
|
|
|
qemu_tcg_rr_wait_io_event(cpu ? cpu : QTAILQ_FIRST(&cpus));
|
2016-10-27 17:10:09 +02:00
|
|
|
deal_with_unplugged_cpus();
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
|
2018-01-30 17:05:06 +01:00
|
|
|
rcu_unregister_thread();
|
2010-03-29 21:23:50 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2017-01-10 11:59:57 +01:00
|
|
|
static void *qemu_hax_cpu_thread_fn(void *arg)
|
|
|
|
{
|
|
|
|
CPUState *cpu = arg;
|
|
|
|
int r;
|
2017-03-20 11:15:49 +01:00
|
|
|
|
2018-01-30 16:28:49 +01:00
|
|
|
rcu_register_thread();
|
2017-03-20 11:15:49 +01:00
|
|
|
qemu_mutex_lock_iothread();
|
2017-01-10 11:59:57 +01:00
|
|
|
qemu_thread_get_self(cpu->thread);
|
|
|
|
|
|
|
|
cpu->thread_id = qemu_get_thread_id();
|
|
|
|
cpu->created = true;
|
|
|
|
cpu->halted = 0;
|
|
|
|
current_cpu = cpu;
|
|
|
|
|
|
|
|
hax_init_vcpu(cpu);
|
|
|
|
qemu_cond_signal(&qemu_cpu_cond);
|
|
|
|
|
2018-01-30 16:28:49 +01:00
|
|
|
do {
|
2017-01-10 11:59:57 +01:00
|
|
|
if (cpu_can_run(cpu)) {
|
|
|
|
r = hax_smp_cpu_exec(cpu);
|
|
|
|
if (r == EXCP_DEBUG) {
|
|
|
|
cpu_handle_guest_debug(cpu);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-11 13:53:12 +01:00
|
|
|
qemu_wait_io_event(cpu);
|
2018-01-30 16:28:49 +01:00
|
|
|
} while (!cpu->unplug || cpu_can_run(cpu));
|
|
|
|
rcu_unregister_thread();
|
2017-01-10 11:59:57 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
i386: hvf: add code base from Google's QEMU repository
This file begins tracking the files that will be the code base for HVF
support in QEMU. This code base is part of Google's QEMU version of
their Android emulator, and can be found at
https://android.googlesource.com/platform/external/qemu/+/emu-master-dev
This code is based on Veertu Inc's vdhh (Veertu Desktop Hosted
Hypervisor), found at https://github.com/veertuinc/vdhh. Everything is
appropriately licensed under GPL v2-or-later, except for the code inside
x86_task.c and x86_task.h, which, deriving from KVM (the Linux kernel),
is licensed GPL v2-only.
This code base already implements a very great deal of functionality,
although Google's version removed from Vertuu's the support for APIC
page and hyperv-related stuff. According to the Android Emulator Release
Notes, Revision 26.1.3 (August 2017), "Hypervisor.framework is now
enabled by default on macOS for 32-bit x86 images to improve performance
and macOS compatibility", although we better use with caution for, as the
same Revision warns us, "If you experience issues with it specifically,
please file a bug report...". The code hasn't seen much update in the
last 5 months, so I think that we can further develop the code with
occasional visiting Google's repository to see if there has been any
update.
On top of Google's code, the following changes were made:
- add code to the configure script to support the --enable-hvf argument.
If the OS is Darwin, it checks for presence of HVF in the system. The
patch also adds strings related to HVF in the file qemu-options.hx.
QEMU will only support the modern syntax style '-M accel=hvf' no enable
hvf; the legacy '-enable-hvf' will not be supported.
- fix styling issues
- add glue code to cpus.c
- move HVFX86EmulatorState field to CPUX86State, changing the
the emulation functions to have a parameter with signature 'CPUX86State *'
instead of 'CPUState *' so we don't have to get the 'env'.
Signed-off-by: Sergio Andres Gomez Del Real <Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-2-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-3-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-5-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-6-Sergio.G.DelReal@gmail.com>
Message-Id: <20170905035457.3753-7-Sergio.G.DelReal@gmail.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-09-13 11:05:09 +02:00
|
|
|
/* The HVF-specific vCPU thread function. This one should only run when the host
|
|
|
|
* CPU supports the VMX "unrestricted guest" feature. */
|
|
|
|
static void *qemu_hvf_cpu_thread_fn(void *arg)
|
|
|
|
{
|
|
|
|
CPUState *cpu = arg;
|
|
|
|
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(hvf_enabled());
|
|
|
|
|
|
|
|
rcu_register_thread();
|
|
|
|
|
|
|
|
qemu_mutex_lock_iothread();
|
|
|
|
qemu_thread_get_self(cpu->thread);
|
|
|
|
|
|
|
|
cpu->thread_id = qemu_get_thread_id();
|
|
|
|
cpu->can_do_io = 1;
|
|
|
|
current_cpu = cpu;
|
|
|
|
|
|
|
|
hvf_init_vcpu(cpu);
|
|
|
|
|
|
|
|
/* signal CPU creation */
|
|
|
|
cpu->created = true;
|
|
|
|
qemu_cond_signal(&qemu_cpu_cond);
|
|
|
|
|
|
|
|
do {
|
|
|
|
if (cpu_can_run(cpu)) {
|
|
|
|
r = hvf_vcpu_exec(cpu);
|
|
|
|
if (r == EXCP_DEBUG) {
|
|
|
|
cpu_handle_guest_debug(cpu);
|
|
|
|
}
|
|
|
|
}
|
2018-01-11 13:53:12 +01:00
|
|
|
qemu_wait_io_event(cpu);
|
i386: hvf: add code base from Google's QEMU repository
This file begins tracking the files that will be the code base for HVF
support in QEMU. This code base is part of Google's QEMU version of
their Android emulator, and can be found at
https://android.googlesource.com/platform/external/qemu/+/emu-master-dev
This code is based on Veertu Inc's vdhh (Veertu Desktop Hosted
Hypervisor), found at https://github.com/veertuinc/vdhh. Everything is
appropriately licensed under GPL v2-or-later, except for the code inside
x86_task.c and x86_task.h, which, deriving from KVM (the Linux kernel),
is licensed GPL v2-only.
This code base already implements a very great deal of functionality,
although Google's version removed from Vertuu's the support for APIC
page and hyperv-related stuff. According to the Android Emulator Release
Notes, Revision 26.1.3 (August 2017), "Hypervisor.framework is now
enabled by default on macOS for 32-bit x86 images to improve performance
and macOS compatibility", although we better use with caution for, as the
same Revision warns us, "If you experience issues with it specifically,
please file a bug report...". The code hasn't seen much update in the
last 5 months, so I think that we can further develop the code with
occasional visiting Google's repository to see if there has been any
update.
On top of Google's code, the following changes were made:
- add code to the configure script to support the --enable-hvf argument.
If the OS is Darwin, it checks for presence of HVF in the system. The
patch also adds strings related to HVF in the file qemu-options.hx.
QEMU will only support the modern syntax style '-M accel=hvf' no enable
hvf; the legacy '-enable-hvf' will not be supported.
- fix styling issues
- add glue code to cpus.c
- move HVFX86EmulatorState field to CPUX86State, changing the
the emulation functions to have a parameter with signature 'CPUX86State *'
instead of 'CPUState *' so we don't have to get the 'env'.
Signed-off-by: Sergio Andres Gomez Del Real <Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-2-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-3-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-5-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-6-Sergio.G.DelReal@gmail.com>
Message-Id: <20170905035457.3753-7-Sergio.G.DelReal@gmail.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-09-13 11:05:09 +02:00
|
|
|
} while (!cpu->unplug || cpu_can_run(cpu));
|
|
|
|
|
|
|
|
hvf_vcpu_destroy(cpu);
|
|
|
|
cpu->created = false;
|
|
|
|
qemu_cond_signal(&qemu_cpu_cond);
|
|
|
|
qemu_mutex_unlock_iothread();
|
2018-01-30 17:05:21 +01:00
|
|
|
rcu_unregister_thread();
|
i386: hvf: add code base from Google's QEMU repository
This file begins tracking the files that will be the code base for HVF
support in QEMU. This code base is part of Google's QEMU version of
their Android emulator, and can be found at
https://android.googlesource.com/platform/external/qemu/+/emu-master-dev
This code is based on Veertu Inc's vdhh (Veertu Desktop Hosted
Hypervisor), found at https://github.com/veertuinc/vdhh. Everything is
appropriately licensed under GPL v2-or-later, except for the code inside
x86_task.c and x86_task.h, which, deriving from KVM (the Linux kernel),
is licensed GPL v2-only.
This code base already implements a very great deal of functionality,
although Google's version removed from Vertuu's the support for APIC
page and hyperv-related stuff. According to the Android Emulator Release
Notes, Revision 26.1.3 (August 2017), "Hypervisor.framework is now
enabled by default on macOS for 32-bit x86 images to improve performance
and macOS compatibility", although we better use with caution for, as the
same Revision warns us, "If you experience issues with it specifically,
please file a bug report...". The code hasn't seen much update in the
last 5 months, so I think that we can further develop the code with
occasional visiting Google's repository to see if there has been any
update.
On top of Google's code, the following changes were made:
- add code to the configure script to support the --enable-hvf argument.
If the OS is Darwin, it checks for presence of HVF in the system. The
patch also adds strings related to HVF in the file qemu-options.hx.
QEMU will only support the modern syntax style '-M accel=hvf' no enable
hvf; the legacy '-enable-hvf' will not be supported.
- fix styling issues
- add glue code to cpus.c
- move HVFX86EmulatorState field to CPUX86State, changing the
the emulation functions to have a parameter with signature 'CPUX86State *'
instead of 'CPUState *' so we don't have to get the 'env'.
Signed-off-by: Sergio Andres Gomez Del Real <Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-2-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-3-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-5-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-6-Sergio.G.DelReal@gmail.com>
Message-Id: <20170905035457.3753-7-Sergio.G.DelReal@gmail.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-09-13 11:05:09 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2018-01-22 22:07:49 +01:00
|
|
|
static void *qemu_whpx_cpu_thread_fn(void *arg)
|
|
|
|
{
|
|
|
|
CPUState *cpu = arg;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
rcu_register_thread();
|
|
|
|
|
|
|
|
qemu_mutex_lock_iothread();
|
|
|
|
qemu_thread_get_self(cpu->thread);
|
|
|
|
cpu->thread_id = qemu_get_thread_id();
|
|
|
|
current_cpu = cpu;
|
|
|
|
|
|
|
|
r = whpx_init_vcpu(cpu);
|
|
|
|
if (r < 0) {
|
|
|
|
fprintf(stderr, "whpx_init_vcpu failed: %s\n", strerror(-r));
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* signal CPU creation */
|
|
|
|
cpu->created = true;
|
|
|
|
qemu_cond_signal(&qemu_cpu_cond);
|
|
|
|
|
|
|
|
do {
|
|
|
|
if (cpu_can_run(cpu)) {
|
|
|
|
r = whpx_vcpu_exec(cpu);
|
|
|
|
if (r == EXCP_DEBUG) {
|
|
|
|
cpu_handle_guest_debug(cpu);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
while (cpu_thread_is_idle(cpu)) {
|
|
|
|
qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
|
|
|
|
}
|
|
|
|
qemu_wait_io_event_common(cpu);
|
|
|
|
} while (!cpu->unplug || cpu_can_run(cpu));
|
|
|
|
|
|
|
|
whpx_destroy_vcpu(cpu);
|
|
|
|
cpu->created = false;
|
|
|
|
qemu_cond_signal(&qemu_cpu_cond);
|
|
|
|
qemu_mutex_unlock_iothread();
|
|
|
|
rcu_unregister_thread();
|
i386: hvf: add code base from Google's QEMU repository
This file begins tracking the files that will be the code base for HVF
support in QEMU. This code base is part of Google's QEMU version of
their Android emulator, and can be found at
https://android.googlesource.com/platform/external/qemu/+/emu-master-dev
This code is based on Veertu Inc's vdhh (Veertu Desktop Hosted
Hypervisor), found at https://github.com/veertuinc/vdhh. Everything is
appropriately licensed under GPL v2-or-later, except for the code inside
x86_task.c and x86_task.h, which, deriving from KVM (the Linux kernel),
is licensed GPL v2-only.
This code base already implements a very great deal of functionality,
although Google's version removed from Vertuu's the support for APIC
page and hyperv-related stuff. According to the Android Emulator Release
Notes, Revision 26.1.3 (August 2017), "Hypervisor.framework is now
enabled by default on macOS for 32-bit x86 images to improve performance
and macOS compatibility", although we better use with caution for, as the
same Revision warns us, "If you experience issues with it specifically,
please file a bug report...". The code hasn't seen much update in the
last 5 months, so I think that we can further develop the code with
occasional visiting Google's repository to see if there has been any
update.
On top of Google's code, the following changes were made:
- add code to the configure script to support the --enable-hvf argument.
If the OS is Darwin, it checks for presence of HVF in the system. The
patch also adds strings related to HVF in the file qemu-options.hx.
QEMU will only support the modern syntax style '-M accel=hvf' no enable
hvf; the legacy '-enable-hvf' will not be supported.
- fix styling issues
- add glue code to cpus.c
- move HVFX86EmulatorState field to CPUX86State, changing the
the emulation functions to have a parameter with signature 'CPUX86State *'
instead of 'CPUState *' so we don't have to get the 'env'.
Signed-off-by: Sergio Andres Gomez Del Real <Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-2-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-3-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-5-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-6-Sergio.G.DelReal@gmail.com>
Message-Id: <20170905035457.3753-7-Sergio.G.DelReal@gmail.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-09-13 11:05:09 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2017-01-10 11:59:57 +01:00
|
|
|
#ifdef _WIN32
|
|
|
|
static void CALLBACK dummy_apc_func(ULONG_PTR unused)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2017-02-23 19:29:14 +01:00
|
|
|
/* Multi-threaded TCG
|
|
|
|
*
|
|
|
|
* In the multi-threaded case each vCPU has its own thread. The TLS
|
|
|
|
* variable current_cpu can be used deep in the code to find the
|
|
|
|
* current CPUState for a given thread.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void *qemu_tcg_cpu_thread_fn(void *arg)
|
|
|
|
{
|
|
|
|
CPUState *cpu = arg;
|
|
|
|
|
2017-03-30 19:32:29 +02:00
|
|
|
g_assert(!use_icount);
|
|
|
|
|
2017-02-23 19:29:14 +01:00
|
|
|
rcu_register_thread();
|
tcg: enable multiple TCG contexts in softmmu
This enables parallel TCG code generation. However, we do not take
advantage of it yet since tb_lock is still held during tb_gen_code.
In user-mode we use a single TCG context; see the documentation
added to tcg_region_init for the rationale.
Note that targets do not need any conversion: targets initialize a
TCGContext (e.g. defining TCG globals), and after this initialization
has finished, the context is cloned by the vCPU threads, each of
them keeping a separate copy.
TCG threads claim one entry in tcg_ctxs[] by atomically increasing
n_tcg_ctxs. Do not be too annoyed by the subsequent atomic_read's
of that variable and tcg_ctxs; they are there just to play nice with
analysis tools such as thread sanitizer.
Note that we do not allocate an array of contexts (we allocate
an array of pointers instead) because when tcg_context_init
is called, we do not know yet how many contexts we'll use since
the bool behind qemu_tcg_mttcg_enabled() isn't set yet.
Previous patches folded some TCG globals into TCGContext. The non-const
globals remaining are only set at init time, i.e. before the TCG
threads are spawned. Here is a list of these set-at-init-time globals
under tcg/:
Only written by tcg_context_init:
- indirect_reg_alloc_order
- tcg_op_defs
Only written by tcg_target_init (called from tcg_context_init):
- tcg_target_available_regs
- tcg_target_call_clobber_regs
- arm: arm_arch, use_idiv_instructions
- i386: have_cmov, have_bmi1, have_bmi2, have_lzcnt,
have_movbe, have_popcnt
- mips: use_movnz_instructions, use_mips32_instructions,
use_mips32r2_instructions, got_sigill (tcg_target_detect_isa)
- ppc: have_isa_2_06, have_isa_3_00, tb_ret_addr
- s390: tb_ret_addr, s390_facilities
- sparc: qemu_ld_trampoline, qemu_st_trampoline (build_trampolines),
use_vis3_instructions
Only written by tcg_prologue_init:
- 'struct jit_code_entry one_entry'
- aarch64: tb_ret_addr
- arm: tb_ret_addr
- i386: tb_ret_addr, guest_base_flags
- ia64: tb_ret_addr
- mips: tb_ret_addr, bswap32_addr, bswap32u_addr, bswap64_addr
Reviewed-by: Richard Henderson <rth@twiddle.net>
Signed-off-by: Emilio G. Cota <cota@braap.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
2017-07-20 00:57:58 +02:00
|
|
|
tcg_register_thread();
|
2017-02-23 19:29:14 +01:00
|
|
|
|
|
|
|
qemu_mutex_lock_iothread();
|
|
|
|
qemu_thread_get_self(cpu->thread);
|
|
|
|
|
|
|
|
cpu->thread_id = qemu_get_thread_id();
|
|
|
|
cpu->created = true;
|
|
|
|
cpu->can_do_io = 1;
|
|
|
|
current_cpu = cpu;
|
|
|
|
qemu_cond_signal(&qemu_cpu_cond);
|
|
|
|
|
|
|
|
/* process any pending work */
|
|
|
|
cpu->exit_request = 1;
|
|
|
|
|
2018-04-25 15:18:28 +02:00
|
|
|
do {
|
2017-02-23 19:29:14 +01:00
|
|
|
if (cpu_can_run(cpu)) {
|
|
|
|
int r;
|
2018-02-27 10:52:48 +01:00
|
|
|
qemu_mutex_unlock_iothread();
|
2017-02-23 19:29:14 +01:00
|
|
|
r = tcg_cpu_exec(cpu);
|
2018-02-27 10:52:48 +01:00
|
|
|
qemu_mutex_lock_iothread();
|
2017-02-23 19:29:14 +01:00
|
|
|
switch (r) {
|
|
|
|
case EXCP_DEBUG:
|
|
|
|
cpu_handle_guest_debug(cpu);
|
|
|
|
break;
|
|
|
|
case EXCP_HALTED:
|
|
|
|
/* during start-up the vCPU is reset and the thread is
|
|
|
|
* kicked several times. If we don't ensure we go back
|
|
|
|
* to sleep in the halted state we won't cleanly
|
|
|
|
* start-up when the vCPU is enabled.
|
|
|
|
*
|
|
|
|
* cpu->halted should ensure we sleep in wait_io_event
|
|
|
|
*/
|
|
|
|
g_assert(cpu->halted);
|
|
|
|
break;
|
2017-02-23 19:29:15 +01:00
|
|
|
case EXCP_ATOMIC:
|
|
|
|
qemu_mutex_unlock_iothread();
|
|
|
|
cpu_exec_step_atomic(cpu);
|
|
|
|
qemu_mutex_lock_iothread();
|
2017-02-23 19:29:14 +01:00
|
|
|
default:
|
|
|
|
/* Ignore everything else? */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
atomic_mb_set(&cpu->exit_request, 0);
|
2018-01-11 13:53:12 +01:00
|
|
|
qemu_wait_io_event(cpu);
|
2018-01-30 17:05:06 +01:00
|
|
|
} while (!cpu->unplug || cpu_can_run(cpu));
|
2017-02-23 19:29:14 +01:00
|
|
|
|
2018-01-30 17:05:06 +01:00
|
|
|
qemu_tcg_destroy_vcpu(cpu);
|
|
|
|
cpu->created = false;
|
|
|
|
qemu_cond_signal(&qemu_cpu_cond);
|
|
|
|
qemu_mutex_unlock_iothread();
|
|
|
|
rcu_unregister_thread();
|
2017-02-23 19:29:14 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-05-03 00:23:30 +02:00
|
|
|
static void qemu_cpu_kick_thread(CPUState *cpu)
|
2011-03-12 17:44:08 +01:00
|
|
|
{
|
|
|
|
#ifndef _WIN32
|
|
|
|
int err;
|
|
|
|
|
2015-08-26 00:19:19 +02:00
|
|
|
if (cpu->thread_kicked) {
|
|
|
|
return;
|
2015-08-18 15:52:09 +02:00
|
|
|
}
|
2015-08-26 00:19:19 +02:00
|
|
|
cpu->thread_kicked = true;
|
2012-05-02 17:00:37 +02:00
|
|
|
err = pthread_kill(cpu->thread->thread, SIG_IPI);
|
2011-03-12 17:44:08 +01:00
|
|
|
if (err) {
|
|
|
|
fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
#else /* _WIN32 */
|
2017-01-10 11:59:57 +01:00
|
|
|
if (!qemu_cpu_is_self(cpu)) {
|
2018-01-22 22:07:49 +01:00
|
|
|
if (whpx_enabled()) {
|
|
|
|
whpx_vcpu_kick(cpu);
|
|
|
|
} else if (!QueueUserAPC(dummy_apc_func, cpu->hThread, 0)) {
|
2017-01-10 11:59:57 +01:00
|
|
|
fprintf(stderr, "%s: QueueUserAPC failed with error %lu\n",
|
|
|
|
__func__, GetLastError());
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
2015-08-26 00:19:19 +02:00
|
|
|
#endif
|
|
|
|
}
|
2013-04-09 18:06:53 +02:00
|
|
|
|
2012-05-03 04:34:15 +02:00
|
|
|
void qemu_cpu_kick(CPUState *cpu)
|
2010-03-29 21:23:50 +02:00
|
|
|
{
|
2012-05-03 01:22:49 +02:00
|
|
|
qemu_cond_broadcast(cpu->halt_cond);
|
2015-08-26 00:19:19 +02:00
|
|
|
if (tcg_enabled()) {
|
2017-02-23 19:29:10 +01:00
|
|
|
cpu_exit(cpu);
|
2017-02-23 19:29:14 +01:00
|
|
|
/* NOP unless doing single-thread RR */
|
2017-02-23 19:29:10 +01:00
|
|
|
qemu_cpu_kick_rr_cpu();
|
2015-08-26 00:19:19 +02:00
|
|
|
} else {
|
2017-01-10 11:59:57 +01:00
|
|
|
if (hax_enabled()) {
|
|
|
|
/*
|
|
|
|
* FIXME: race condition with the exit_request check in
|
|
|
|
* hax_vcpu_hax_exec
|
|
|
|
*/
|
|
|
|
cpu->exit_request = 1;
|
|
|
|
}
|
2015-08-26 00:19:19 +02:00
|
|
|
qemu_cpu_kick_thread(cpu);
|
|
|
|
}
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
|
2011-02-01 22:15:59 +01:00
|
|
|
void qemu_cpu_kick_self(void)
|
2010-03-29 21:23:50 +02:00
|
|
|
{
|
2013-05-27 05:17:50 +02:00
|
|
|
assert(current_cpu);
|
2015-08-18 15:52:09 +02:00
|
|
|
qemu_cpu_kick_thread(current_cpu);
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
|
2012-05-02 22:23:49 +02:00
|
|
|
bool qemu_cpu_is_self(CPUState *cpu)
|
2010-03-29 21:23:50 +02:00
|
|
|
{
|
2012-05-02 17:00:37 +02:00
|
|
|
return qemu_thread_is_self(cpu->thread);
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
|
2015-01-21 12:09:14 +01:00
|
|
|
bool qemu_in_vcpu_thread(void)
|
2012-09-18 16:30:11 +02:00
|
|
|
{
|
2013-05-27 05:17:50 +02:00
|
|
|
return current_cpu && qemu_cpu_is_self(current_cpu);
|
2012-09-18 16:30:11 +02:00
|
|
|
}
|
|
|
|
|
2015-06-18 18:47:19 +02:00
|
|
|
static __thread bool iothread_locked = false;
|
|
|
|
|
|
|
|
bool qemu_mutex_iothread_locked(void)
|
|
|
|
{
|
|
|
|
return iothread_locked;
|
|
|
|
}
|
|
|
|
|
2010-03-29 21:23:50 +02:00
|
|
|
void qemu_mutex_lock_iothread(void)
|
|
|
|
{
|
tcg: drop global lock during TCG code execution
This finally allows TCG to benefit from the iothread introduction: Drop
the global mutex while running pure TCG CPU code. Reacquire the lock
when entering MMIO or PIO emulation, or when leaving the TCG loop.
We have to revert a few optimization for the current TCG threading
model, namely kicking the TCG thread in qemu_mutex_lock_iothread and not
kicking it in qemu_cpu_kick. We also need to disable RAM block
reordering until we have a more efficient locking mechanism at hand.
Still, a Linux x86 UP guest and my Musicpal ARM model boot fine here.
These numbers demonstrate where we gain something:
20338 jan 20 0 331m 75m 6904 R 99 0.9 0:50.95 qemu-system-arm
20337 jan 20 0 331m 75m 6904 S 20 0.9 0:26.50 qemu-system-arm
The guest CPU was fully loaded, but the iothread could still run mostly
independent on a second core. Without the patch we don't get beyond
32206 jan 20 0 330m 73m 7036 R 82 0.9 1:06.00 qemu-system-arm
32204 jan 20 0 330m 73m 7036 S 21 0.9 0:17.03 qemu-system-arm
We don't benefit significantly, though, when the guest is not fully
loading a host CPU.
Signed-off-by: Jan Kiszka <jan.kiszka@siemens.com>
Message-Id: <1439220437-23957-10-git-send-email-fred.konrad@greensocs.com>
[FK: Rebase, fix qemu_devices_reset deadlock, rm address_space_* mutex]
Signed-off-by: KONRAD Frederic <fred.konrad@greensocs.com>
[EGC: fixed iothread lock for cpu-exec IRQ handling]
Signed-off-by: Emilio G. Cota <cota@braap.org>
[AJB: -smp single-threaded fix, clean commit msg, BQL fixes]
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Reviewed-by: Richard Henderson <rth@twiddle.net>
Reviewed-by: Pranith Kumar <bobby.prani@gmail.com>
[PM: target-arm changes]
Acked-by: Peter Maydell <peter.maydell@linaro.org>
2017-02-23 19:29:11 +01:00
|
|
|
g_assert(!qemu_mutex_iothread_locked());
|
|
|
|
qemu_mutex_lock(&qemu_global_mutex);
|
2015-06-18 18:47:19 +02:00
|
|
|
iothread_locked = true;
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void qemu_mutex_unlock_iothread(void)
|
|
|
|
{
|
tcg: drop global lock during TCG code execution
This finally allows TCG to benefit from the iothread introduction: Drop
the global mutex while running pure TCG CPU code. Reacquire the lock
when entering MMIO or PIO emulation, or when leaving the TCG loop.
We have to revert a few optimization for the current TCG threading
model, namely kicking the TCG thread in qemu_mutex_lock_iothread and not
kicking it in qemu_cpu_kick. We also need to disable RAM block
reordering until we have a more efficient locking mechanism at hand.
Still, a Linux x86 UP guest and my Musicpal ARM model boot fine here.
These numbers demonstrate where we gain something:
20338 jan 20 0 331m 75m 6904 R 99 0.9 0:50.95 qemu-system-arm
20337 jan 20 0 331m 75m 6904 S 20 0.9 0:26.50 qemu-system-arm
The guest CPU was fully loaded, but the iothread could still run mostly
independent on a second core. Without the patch we don't get beyond
32206 jan 20 0 330m 73m 7036 R 82 0.9 1:06.00 qemu-system-arm
32204 jan 20 0 330m 73m 7036 S 21 0.9 0:17.03 qemu-system-arm
We don't benefit significantly, though, when the guest is not fully
loading a host CPU.
Signed-off-by: Jan Kiszka <jan.kiszka@siemens.com>
Message-Id: <1439220437-23957-10-git-send-email-fred.konrad@greensocs.com>
[FK: Rebase, fix qemu_devices_reset deadlock, rm address_space_* mutex]
Signed-off-by: KONRAD Frederic <fred.konrad@greensocs.com>
[EGC: fixed iothread lock for cpu-exec IRQ handling]
Signed-off-by: Emilio G. Cota <cota@braap.org>
[AJB: -smp single-threaded fix, clean commit msg, BQL fixes]
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Reviewed-by: Richard Henderson <rth@twiddle.net>
Reviewed-by: Pranith Kumar <bobby.prani@gmail.com>
[PM: target-arm changes]
Acked-by: Peter Maydell <peter.maydell@linaro.org>
2017-02-23 19:29:11 +01:00
|
|
|
g_assert(qemu_mutex_iothread_locked());
|
2015-06-18 18:47:19 +02:00
|
|
|
iothread_locked = false;
|
2010-03-29 21:23:50 +02:00
|
|
|
qemu_mutex_unlock(&qemu_global_mutex);
|
|
|
|
}
|
|
|
|
|
2016-10-27 17:09:58 +02:00
|
|
|
static bool all_vcpus_paused(void)
|
2010-03-29 21:23:50 +02:00
|
|
|
{
|
2013-06-24 23:50:24 +02:00
|
|
|
CPUState *cpu;
|
2010-03-29 21:23:50 +02:00
|
|
|
|
2013-06-24 23:50:24 +02:00
|
|
|
CPU_FOREACH(cpu) {
|
2013-05-29 22:29:20 +02:00
|
|
|
if (!cpu->stopped) {
|
2016-10-27 17:09:58 +02:00
|
|
|
return false;
|
2011-02-07 12:19:14 +01:00
|
|
|
}
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
|
2016-10-27 17:09:58 +02:00
|
|
|
return true;
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void pause_all_vcpus(void)
|
|
|
|
{
|
2013-06-24 23:50:24 +02:00
|
|
|
CPUState *cpu;
|
2010-03-29 21:23:50 +02:00
|
|
|
|
2013-08-21 17:03:02 +02:00
|
|
|
qemu_clock_enable(QEMU_CLOCK_VIRTUAL, false);
|
2013-06-24 23:50:24 +02:00
|
|
|
CPU_FOREACH(cpu) {
|
2017-11-29 20:12:15 +01:00
|
|
|
if (qemu_cpu_is_self(cpu)) {
|
|
|
|
qemu_cpu_stop(cpu, true);
|
|
|
|
} else {
|
|
|
|
cpu->stop = true;
|
|
|
|
qemu_cpu_kick(cpu);
|
|
|
|
}
|
2012-02-17 18:31:16 +01:00
|
|
|
}
|
|
|
|
|
2018-02-27 10:52:48 +01:00
|
|
|
/* We need to drop the replay_lock so any vCPU threads woken up
|
|
|
|
* can finish their replay tasks
|
|
|
|
*/
|
|
|
|
replay_mutex_unlock();
|
|
|
|
|
2010-03-29 21:23:50 +02:00
|
|
|
while (!all_vcpus_paused()) {
|
2011-03-12 17:44:02 +01:00
|
|
|
qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
|
2013-06-24 23:50:24 +02:00
|
|
|
CPU_FOREACH(cpu) {
|
2013-05-29 22:29:20 +02:00
|
|
|
qemu_cpu_kick(cpu);
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
}
|
2018-02-27 10:52:48 +01:00
|
|
|
|
|
|
|
qemu_mutex_unlock_iothread();
|
|
|
|
replay_mutex_lock();
|
|
|
|
qemu_mutex_lock_iothread();
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
|
2013-04-23 10:29:37 +02:00
|
|
|
void cpu_resume(CPUState *cpu)
|
|
|
|
{
|
|
|
|
cpu->stop = false;
|
|
|
|
cpu->stopped = false;
|
|
|
|
qemu_cpu_kick(cpu);
|
|
|
|
}
|
|
|
|
|
2010-03-29 21:23:50 +02:00
|
|
|
void resume_all_vcpus(void)
|
|
|
|
{
|
2013-06-24 23:50:24 +02:00
|
|
|
CPUState *cpu;
|
2010-03-29 21:23:50 +02:00
|
|
|
|
2013-08-21 17:03:02 +02:00
|
|
|
qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
|
2013-06-24 23:50:24 +02:00
|
|
|
CPU_FOREACH(cpu) {
|
2013-05-29 22:29:20 +02:00
|
|
|
cpu_resume(cpu);
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-30 16:40:12 +01:00
|
|
|
void cpu_remove_sync(CPUState *cpu)
|
2016-05-12 05:48:13 +02:00
|
|
|
{
|
|
|
|
cpu->stop = true;
|
|
|
|
cpu->unplug = true;
|
|
|
|
qemu_cpu_kick(cpu);
|
2018-01-30 16:40:12 +01:00
|
|
|
qemu_mutex_unlock_iothread();
|
|
|
|
qemu_thread_join(cpu->thread);
|
|
|
|
qemu_mutex_lock_iothread();
|
2016-05-12 05:48:14 +02:00
|
|
|
}
|
|
|
|
|
2014-01-30 11:20:32 +01:00
|
|
|
/* For temporary buffers for forming a name */
|
|
|
|
#define VCPU_THREAD_NAME_SIZE 16
|
|
|
|
|
2012-05-03 01:50:44 +02:00
|
|
|
static void qemu_tcg_init_vcpu(CPUState *cpu)
|
2010-03-29 21:23:50 +02:00
|
|
|
{
|
2014-01-30 11:20:32 +01:00
|
|
|
char thread_name[VCPU_THREAD_NAME_SIZE];
|
2017-02-23 19:29:14 +01:00
|
|
|
static QemuCond *single_tcg_halt_cond;
|
|
|
|
static QemuThread *single_tcg_cpu_thread;
|
tcg: introduce regions to split code_gen_buffer
This is groundwork for supporting multiple TCG contexts.
The naive solution here is to split code_gen_buffer statically
among the TCG threads; this however results in poor utilization
if translation needs are different across TCG threads.
What we do here is to add an extra layer of indirection, assigning
regions that act just like pages do in virtual memory allocation.
(BTW if you are wondering about the chosen naming, I did not want
to use blocks or pages because those are already heavily used in QEMU).
We use a global lock to serialize allocations as well as statistics
reporting (we now export the size of the used code_gen_buffer with
tcg_code_size()). Note that for the allocator we could just use
a counter and atomic_inc; however, that would complicate the gathering
of tcg_code_size()-like stats. So given that the region operations are
not a fast path, a lock seems the most reasonable choice.
The effectiveness of this approach is clear after seeing some numbers.
I used the bootup+shutdown of debian-arm with '-tb-size 80' as a benchmark.
Note that I'm evaluating this after enabling per-thread TCG (which
is done by a subsequent commit).
* -smp 1, 1 region (entire buffer):
qemu: flush code_size=83885014 nb_tbs=154739 avg_tb_size=357
qemu: flush code_size=83884902 nb_tbs=153136 avg_tb_size=363
qemu: flush code_size=83885014 nb_tbs=152777 avg_tb_size=364
qemu: flush code_size=83884950 nb_tbs=150057 avg_tb_size=373
qemu: flush code_size=83884998 nb_tbs=150234 avg_tb_size=373
qemu: flush code_size=83885014 nb_tbs=154009 avg_tb_size=360
qemu: flush code_size=83885014 nb_tbs=151007 avg_tb_size=370
qemu: flush code_size=83885014 nb_tbs=151816 avg_tb_size=367
That is, 8 flushes.
* -smp 8, 32 regions (80/32 MB per region) [i.e. this patch]:
qemu: flush code_size=76328008 nb_tbs=141040 avg_tb_size=356
qemu: flush code_size=75366534 nb_tbs=138000 avg_tb_size=361
qemu: flush code_size=76864546 nb_tbs=140653 avg_tb_size=361
qemu: flush code_size=76309084 nb_tbs=135945 avg_tb_size=375
qemu: flush code_size=74581856 nb_tbs=132909 avg_tb_size=375
qemu: flush code_size=73927256 nb_tbs=135616 avg_tb_size=360
qemu: flush code_size=78629426 nb_tbs=142896 avg_tb_size=365
qemu: flush code_size=76667052 nb_tbs=138508 avg_tb_size=368
Again, 8 flushes. Note how buffer utilization is not 100%, but it
is close. Smaller region sizes would yield higher utilization,
but we want region allocation to be rare (it acquires a lock), so
we do not want to go too small.
* -smp 8, static partitioning of 8 regions (10 MB per region):
qemu: flush code_size=21936504 nb_tbs=40570 avg_tb_size=354
qemu: flush code_size=11472174 nb_tbs=20633 avg_tb_size=370
qemu: flush code_size=11603976 nb_tbs=21059 avg_tb_size=365
qemu: flush code_size=23254872 nb_tbs=41243 avg_tb_size=377
qemu: flush code_size=28289496 nb_tbs=52057 avg_tb_size=358
qemu: flush code_size=43605160 nb_tbs=78896 avg_tb_size=367
qemu: flush code_size=45166552 nb_tbs=82158 avg_tb_size=364
qemu: flush code_size=63289640 nb_tbs=116494 avg_tb_size=358
qemu: flush code_size=51389960 nb_tbs=93937 avg_tb_size=362
qemu: flush code_size=59665928 nb_tbs=107063 avg_tb_size=372
qemu: flush code_size=38380824 nb_tbs=68597 avg_tb_size=374
qemu: flush code_size=44884568 nb_tbs=79901 avg_tb_size=376
qemu: flush code_size=50782632 nb_tbs=90681 avg_tb_size=374
qemu: flush code_size=39848888 nb_tbs=71433 avg_tb_size=372
qemu: flush code_size=64708840 nb_tbs=119052 avg_tb_size=359
qemu: flush code_size=49830008 nb_tbs=90992 avg_tb_size=362
qemu: flush code_size=68372408 nb_tbs=123442 avg_tb_size=368
qemu: flush code_size=33555560 nb_tbs=59514 avg_tb_size=378
qemu: flush code_size=44748344 nb_tbs=80974 avg_tb_size=367
qemu: flush code_size=37104248 nb_tbs=67609 avg_tb_size=364
That is, 20 flushes. Note how a static partitioning approach uses
the code buffer poorly, leading to many unnecessary flushes.
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: Emilio G. Cota <cota@braap.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
2017-07-08 01:24:20 +02:00
|
|
|
static int tcg_region_inited;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize TCG regions--once. Now is a good time, because:
|
|
|
|
* (1) TCG's init context, prologue and target globals have been set up.
|
|
|
|
* (2) qemu_tcg_mttcg_enabled() works now (TCG init code runs before the
|
|
|
|
* -accel flag is processed, so the check doesn't work then).
|
|
|
|
*/
|
|
|
|
if (!tcg_region_inited) {
|
|
|
|
tcg_region_inited = 1;
|
|
|
|
tcg_region_init();
|
|
|
|
}
|
2014-01-30 11:20:32 +01:00
|
|
|
|
2017-02-23 19:29:14 +01:00
|
|
|
if (qemu_tcg_mttcg_enabled() || !single_tcg_cpu_thread) {
|
2012-05-02 17:00:37 +02:00
|
|
|
cpu->thread = g_malloc0(sizeof(QemuThread));
|
2012-05-03 01:22:49 +02:00
|
|
|
cpu->halt_cond = g_malloc0(sizeof(QemuCond));
|
|
|
|
qemu_cond_init(cpu->halt_cond);
|
2017-02-23 19:29:14 +01:00
|
|
|
|
|
|
|
if (qemu_tcg_mttcg_enabled()) {
|
|
|
|
/* create a thread per vCPU with TCG (MTTCG) */
|
|
|
|
parallel_cpus = true;
|
|
|
|
snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/TCG",
|
2014-01-30 11:20:32 +01:00
|
|
|
cpu->cpu_index);
|
2017-02-23 19:29:14 +01:00
|
|
|
|
|
|
|
qemu_thread_create(cpu->thread, thread_name, qemu_tcg_cpu_thread_fn,
|
|
|
|
cpu, QEMU_THREAD_JOINABLE);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
/* share a single thread for all cpus with TCG */
|
|
|
|
snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "ALL CPUs/TCG");
|
|
|
|
qemu_thread_create(cpu->thread, thread_name,
|
|
|
|
qemu_tcg_rr_cpu_thread_fn,
|
|
|
|
cpu, QEMU_THREAD_JOINABLE);
|
|
|
|
|
|
|
|
single_tcg_halt_cond = cpu->halt_cond;
|
|
|
|
single_tcg_cpu_thread = cpu->thread;
|
|
|
|
}
|
2011-12-13 13:43:52 +01:00
|
|
|
#ifdef _WIN32
|
2012-05-02 17:00:37 +02:00
|
|
|
cpu->hThread = qemu_thread_get_handle(cpu->thread);
|
2011-12-13 13:43:52 +01:00
|
|
|
#endif
|
2010-03-29 21:23:50 +02:00
|
|
|
} else {
|
2017-02-23 19:29:14 +01:00
|
|
|
/* For non-MTTCG cases we share the thread */
|
|
|
|
cpu->thread = single_tcg_cpu_thread;
|
|
|
|
cpu->halt_cond = single_tcg_halt_cond;
|
2018-02-09 20:52:37 +01:00
|
|
|
cpu->thread_id = first_cpu->thread_id;
|
|
|
|
cpu->can_do_io = 1;
|
|
|
|
cpu->created = true;
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-10 11:59:57 +01:00
|
|
|
static void qemu_hax_start_vcpu(CPUState *cpu)
|
|
|
|
{
|
|
|
|
char thread_name[VCPU_THREAD_NAME_SIZE];
|
|
|
|
|
|
|
|
cpu->thread = g_malloc0(sizeof(QemuThread));
|
|
|
|
cpu->halt_cond = g_malloc0(sizeof(QemuCond));
|
|
|
|
qemu_cond_init(cpu->halt_cond);
|
|
|
|
|
|
|
|
snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/HAX",
|
|
|
|
cpu->cpu_index);
|
|
|
|
qemu_thread_create(cpu->thread, thread_name, qemu_hax_cpu_thread_fn,
|
|
|
|
cpu, QEMU_THREAD_JOINABLE);
|
|
|
|
#ifdef _WIN32
|
|
|
|
cpu->hThread = qemu_thread_get_handle(cpu->thread);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2013-05-27 02:20:39 +02:00
|
|
|
static void qemu_kvm_start_vcpu(CPUState *cpu)
|
2010-03-29 21:23:50 +02:00
|
|
|
{
|
2014-01-30 11:20:32 +01:00
|
|
|
char thread_name[VCPU_THREAD_NAME_SIZE];
|
|
|
|
|
2012-05-02 17:00:37 +02:00
|
|
|
cpu->thread = g_malloc0(sizeof(QemuThread));
|
2012-05-03 01:22:49 +02:00
|
|
|
cpu->halt_cond = g_malloc0(sizeof(QemuCond));
|
|
|
|
qemu_cond_init(cpu->halt_cond);
|
2014-01-30 11:20:32 +01:00
|
|
|
snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/KVM",
|
|
|
|
cpu->cpu_index);
|
|
|
|
qemu_thread_create(cpu->thread, thread_name, qemu_kvm_cpu_thread_fn,
|
|
|
|
cpu, QEMU_THREAD_JOINABLE);
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
|
i386: hvf: add code base from Google's QEMU repository
This file begins tracking the files that will be the code base for HVF
support in QEMU. This code base is part of Google's QEMU version of
their Android emulator, and can be found at
https://android.googlesource.com/platform/external/qemu/+/emu-master-dev
This code is based on Veertu Inc's vdhh (Veertu Desktop Hosted
Hypervisor), found at https://github.com/veertuinc/vdhh. Everything is
appropriately licensed under GPL v2-or-later, except for the code inside
x86_task.c and x86_task.h, which, deriving from KVM (the Linux kernel),
is licensed GPL v2-only.
This code base already implements a very great deal of functionality,
although Google's version removed from Vertuu's the support for APIC
page and hyperv-related stuff. According to the Android Emulator Release
Notes, Revision 26.1.3 (August 2017), "Hypervisor.framework is now
enabled by default on macOS for 32-bit x86 images to improve performance
and macOS compatibility", although we better use with caution for, as the
same Revision warns us, "If you experience issues with it specifically,
please file a bug report...". The code hasn't seen much update in the
last 5 months, so I think that we can further develop the code with
occasional visiting Google's repository to see if there has been any
update.
On top of Google's code, the following changes were made:
- add code to the configure script to support the --enable-hvf argument.
If the OS is Darwin, it checks for presence of HVF in the system. The
patch also adds strings related to HVF in the file qemu-options.hx.
QEMU will only support the modern syntax style '-M accel=hvf' no enable
hvf; the legacy '-enable-hvf' will not be supported.
- fix styling issues
- add glue code to cpus.c
- move HVFX86EmulatorState field to CPUX86State, changing the
the emulation functions to have a parameter with signature 'CPUX86State *'
instead of 'CPUState *' so we don't have to get the 'env'.
Signed-off-by: Sergio Andres Gomez Del Real <Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-2-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-3-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-5-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-6-Sergio.G.DelReal@gmail.com>
Message-Id: <20170905035457.3753-7-Sergio.G.DelReal@gmail.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-09-13 11:05:09 +02:00
|
|
|
static void qemu_hvf_start_vcpu(CPUState *cpu)
|
|
|
|
{
|
|
|
|
char thread_name[VCPU_THREAD_NAME_SIZE];
|
|
|
|
|
|
|
|
/* HVF currently does not support TCG, and only runs in
|
|
|
|
* unrestricted-guest mode. */
|
|
|
|
assert(hvf_enabled());
|
|
|
|
|
|
|
|
cpu->thread = g_malloc0(sizeof(QemuThread));
|
|
|
|
cpu->halt_cond = g_malloc0(sizeof(QemuCond));
|
|
|
|
qemu_cond_init(cpu->halt_cond);
|
|
|
|
|
|
|
|
snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/HVF",
|
|
|
|
cpu->cpu_index);
|
|
|
|
qemu_thread_create(cpu->thread, thread_name, qemu_hvf_cpu_thread_fn,
|
|
|
|
cpu, QEMU_THREAD_JOINABLE);
|
|
|
|
}
|
|
|
|
|
2018-01-22 22:07:49 +01:00
|
|
|
static void qemu_whpx_start_vcpu(CPUState *cpu)
|
|
|
|
{
|
|
|
|
char thread_name[VCPU_THREAD_NAME_SIZE];
|
|
|
|
|
|
|
|
cpu->thread = g_malloc0(sizeof(QemuThread));
|
|
|
|
cpu->halt_cond = g_malloc0(sizeof(QemuCond));
|
|
|
|
qemu_cond_init(cpu->halt_cond);
|
|
|
|
snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/WHPX",
|
|
|
|
cpu->cpu_index);
|
|
|
|
qemu_thread_create(cpu->thread, thread_name, qemu_whpx_cpu_thread_fn,
|
|
|
|
cpu, QEMU_THREAD_JOINABLE);
|
|
|
|
#ifdef _WIN32
|
|
|
|
cpu->hThread = qemu_thread_get_handle(cpu->thread);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2013-05-27 02:24:35 +02:00
|
|
|
static void qemu_dummy_start_vcpu(CPUState *cpu)
|
2012-03-28 15:42:02 +02:00
|
|
|
{
|
2014-01-30 11:20:32 +01:00
|
|
|
char thread_name[VCPU_THREAD_NAME_SIZE];
|
|
|
|
|
2012-05-02 17:00:37 +02:00
|
|
|
cpu->thread = g_malloc0(sizeof(QemuThread));
|
2012-05-03 01:22:49 +02:00
|
|
|
cpu->halt_cond = g_malloc0(sizeof(QemuCond));
|
|
|
|
qemu_cond_init(cpu->halt_cond);
|
2014-01-30 11:20:32 +01:00
|
|
|
snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/DUMMY",
|
|
|
|
cpu->cpu_index);
|
|
|
|
qemu_thread_create(cpu->thread, thread_name, qemu_dummy_cpu_thread_fn, cpu,
|
2012-03-28 15:42:02 +02:00
|
|
|
QEMU_THREAD_JOINABLE);
|
|
|
|
}
|
|
|
|
|
2013-05-27 03:23:24 +02:00
|
|
|
void qemu_init_vcpu(CPUState *cpu)
|
2010-03-29 21:23:50 +02:00
|
|
|
{
|
2012-12-17 03:27:07 +01:00
|
|
|
cpu->nr_cores = smp_cores;
|
|
|
|
cpu->nr_threads = smp_threads;
|
2012-05-02 23:26:21 +02:00
|
|
|
cpu->stopped = true;
|
2016-01-21 15:15:04 +01:00
|
|
|
|
|
|
|
if (!cpu->as) {
|
|
|
|
/* If the target cpu hasn't set up any address spaces itself,
|
|
|
|
* give it the default one.
|
|
|
|
*/
|
2016-01-21 15:15:04 +01:00
|
|
|
cpu->num_ases = 1;
|
2017-11-23 10:23:32 +01:00
|
|
|
cpu_address_space_init(cpu, 0, "cpu-memory", cpu->memory);
|
2016-01-21 15:15:04 +01:00
|
|
|
}
|
|
|
|
|
2011-02-07 12:19:14 +01:00
|
|
|
if (kvm_enabled()) {
|
2013-05-27 02:20:39 +02:00
|
|
|
qemu_kvm_start_vcpu(cpu);
|
2017-01-10 11:59:57 +01:00
|
|
|
} else if (hax_enabled()) {
|
|
|
|
qemu_hax_start_vcpu(cpu);
|
i386: hvf: add code base from Google's QEMU repository
This file begins tracking the files that will be the code base for HVF
support in QEMU. This code base is part of Google's QEMU version of
their Android emulator, and can be found at
https://android.googlesource.com/platform/external/qemu/+/emu-master-dev
This code is based on Veertu Inc's vdhh (Veertu Desktop Hosted
Hypervisor), found at https://github.com/veertuinc/vdhh. Everything is
appropriately licensed under GPL v2-or-later, except for the code inside
x86_task.c and x86_task.h, which, deriving from KVM (the Linux kernel),
is licensed GPL v2-only.
This code base already implements a very great deal of functionality,
although Google's version removed from Vertuu's the support for APIC
page and hyperv-related stuff. According to the Android Emulator Release
Notes, Revision 26.1.3 (August 2017), "Hypervisor.framework is now
enabled by default on macOS for 32-bit x86 images to improve performance
and macOS compatibility", although we better use with caution for, as the
same Revision warns us, "If you experience issues with it specifically,
please file a bug report...". The code hasn't seen much update in the
last 5 months, so I think that we can further develop the code with
occasional visiting Google's repository to see if there has been any
update.
On top of Google's code, the following changes were made:
- add code to the configure script to support the --enable-hvf argument.
If the OS is Darwin, it checks for presence of HVF in the system. The
patch also adds strings related to HVF in the file qemu-options.hx.
QEMU will only support the modern syntax style '-M accel=hvf' no enable
hvf; the legacy '-enable-hvf' will not be supported.
- fix styling issues
- add glue code to cpus.c
- move HVFX86EmulatorState field to CPUX86State, changing the
the emulation functions to have a parameter with signature 'CPUX86State *'
instead of 'CPUState *' so we don't have to get the 'env'.
Signed-off-by: Sergio Andres Gomez Del Real <Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-2-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-3-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-5-Sergio.G.DelReal@gmail.com>
Message-Id: <20170913090522.4022-6-Sergio.G.DelReal@gmail.com>
Message-Id: <20170905035457.3753-7-Sergio.G.DelReal@gmail.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-09-13 11:05:09 +02:00
|
|
|
} else if (hvf_enabled()) {
|
|
|
|
qemu_hvf_start_vcpu(cpu);
|
2012-03-28 15:42:02 +02:00
|
|
|
} else if (tcg_enabled()) {
|
2012-05-03 01:50:44 +02:00
|
|
|
qemu_tcg_init_vcpu(cpu);
|
2018-01-22 22:07:49 +01:00
|
|
|
} else if (whpx_enabled()) {
|
|
|
|
qemu_whpx_start_vcpu(cpu);
|
2012-03-28 15:42:02 +02:00
|
|
|
} else {
|
2013-05-27 02:24:35 +02:00
|
|
|
qemu_dummy_start_vcpu(cpu);
|
2011-02-07 12:19:14 +01:00
|
|
|
}
|
2018-02-09 20:52:38 +01:00
|
|
|
|
|
|
|
while (!cpu->created) {
|
|
|
|
qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
|
|
|
|
}
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
|
2011-02-01 22:15:43 +01:00
|
|
|
void cpu_stop_current(void)
|
2010-03-29 21:23:50 +02:00
|
|
|
{
|
2013-05-27 05:17:50 +02:00
|
|
|
if (current_cpu) {
|
2017-11-29 20:12:15 +01:00
|
|
|
qemu_cpu_stop(current_cpu, true);
|
2011-02-01 22:15:43 +01:00
|
|
|
}
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
|
2013-07-05 13:49:54 +02:00
|
|
|
int vm_stop(RunState state)
|
2010-03-29 21:23:50 +02:00
|
|
|
{
|
2012-09-18 16:30:11 +02:00
|
|
|
if (qemu_in_vcpu_thread()) {
|
2014-06-05 14:53:58 +02:00
|
|
|
qemu_system_vmstop_request_prepare();
|
2011-07-29 19:26:33 +02:00
|
|
|
qemu_system_vmstop_request(state);
|
2010-03-29 21:23:50 +02:00
|
|
|
/*
|
|
|
|
* FIXME: should not return to device code in case
|
|
|
|
* vm_stop() has been requested.
|
|
|
|
*/
|
2011-02-01 22:15:43 +01:00
|
|
|
cpu_stop_current();
|
2013-07-05 13:49:54 +02:00
|
|
|
return 0;
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
2013-07-05 13:49:54 +02:00
|
|
|
|
2018-03-07 15:42:05 +01:00
|
|
|
return do_vm_stop(state, true);
|
2010-03-29 21:23:50 +02:00
|
|
|
}
|
|
|
|
|
2017-02-14 18:07:47 +01:00
|
|
|
/**
|
|
|
|
* Prepare for (re)starting the VM.
|
|
|
|
* Returns -1 if the vCPUs are not to be restarted (e.g. if they are already
|
|
|
|
* running or in case of an error condition), 0 otherwise.
|
|
|
|
*/
|
|
|
|
int vm_prepare_start(void)
|
|
|
|
{
|
|
|
|
RunState requested;
|
|
|
|
|
|
|
|
qemu_vmstop_requested(&requested);
|
|
|
|
if (runstate_is_running() && requested == RUN_STATE__MAX) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Ensure that a STOP/RESUME pair of events is emitted if a
|
|
|
|
* vmstop request was pending. The BLOCK_IO_ERROR event, for
|
|
|
|
* example, according to documentation is always followed by
|
|
|
|
* the STOP event.
|
|
|
|
*/
|
|
|
|
if (runstate_is_running()) {
|
|
|
|
qapi_event_send_stop(&error_abort);
|
cpus: Fix event order on resume of stopped guest
When resume of a stopped guest immediately runs into block device
errors, the BLOCK_IO_ERROR event is sent before the RESUME event.
Reproducer:
1. Create a scratch image
$ dd if=/dev/zero of=scratch.img bs=1M count=100
Size doesn't actually matter.
2. Prepare blkdebug configuration:
$ cat >blkdebug.conf <<EOF
[inject-error]
event = "write_aio"
errno = "5"
EOF
Note that errno 5 is EIO.
3. Run a guest with an additional scratch disk, i.e. with additional
arguments
-drive if=none,id=scratch-drive,format=raw,werror=stop,file=blkdebug:blkdebug.conf:scratch.img
-device virtio-blk-pci,id=scratch,drive=scratch-drive
The blkdebug part makes all writes to the scratch drive fail with
EIO. The werror=stop pauses the guest on write errors.
4. Connect to the QMP socket e.g. like this:
$ socat UNIX:/your/qmp/socket READLINE,history=$HOME/.qmp_history,prompt='QMP> '
Issue QMP command 'qmp_capabilities':
QMP> { "execute": "qmp_capabilities" }
5. Boot the guest.
6. In the guest, write to the scratch disk, e.g. like this:
# dd if=/dev/zero of=/dev/vdb count=1
Do double-check the device specified with of= is actually the
scratch device!
7. Issue QMP command 'cont':
QMP> { "execute": "cont" }
After step 6, I get a BLOCK_IO_ERROR event followed by a STOP event. Good.
After step 7, I get BLOCK_IO_ERROR, then RESUME, then STOP. Not so
good; I'd expect RESUME, then BLOCK_IO_ERROR, then STOP.
The funny event order confuses libvirt: virsh -r domstate DOMAIN
--reason reports "paused (unknown)" rather than "paused (I/O error)".
The culprit is vm_prepare_start().
/* Ensure that a STOP/RESUME pair of events is emitted if a
* vmstop request was pending. The BLOCK_IO_ERROR event, for
* example, according to documentation is always followed by
* the STOP event.
*/
if (runstate_is_running()) {
qapi_event_send_stop(&error_abort);
res = -1;
} else {
replay_enable_events();
cpu_enable_ticks();
runstate_set(RUN_STATE_RUNNING);
vm_state_notify(1, RUN_STATE_RUNNING);
}
/* We are sending this now, but the CPUs will be resumed shortly later */
qapi_event_send_resume(&error_abort);
return res;
When resuming a stopped guest, we take the else branch before we get
to sending RESUME. vm_state_notify() runs virtio_vmstate_change(),
among other things. This restarts I/O, triggering the BLOCK_IO_ERROR
event.
Reshuffle vm_prepare_start() to send the RESUME event earlier.
Fixes RHBZ 1566153.
Cc: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-Id: <20180423084518.2426-1-armbru@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2018-04-23 10:45:18 +02:00
|
|
|
qapi_event_send_resume(&error_abort);
|
|
|
|
return -1;
|
2017-02-14 18:07:47 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* We are sending this now, but the CPUs will be resumed shortly later */
|
|
|
|
qapi_event_send_resume(&error_abort);
|
cpus: Fix event order on resume of stopped guest
When resume of a stopped guest immediately runs into block device
errors, the BLOCK_IO_ERROR event is sent before the RESUME event.
Reproducer:
1. Create a scratch image
$ dd if=/dev/zero of=scratch.img bs=1M count=100
Size doesn't actually matter.
2. Prepare blkdebug configuration:
$ cat >blkdebug.conf <<EOF
[inject-error]
event = "write_aio"
errno = "5"
EOF
Note that errno 5 is EIO.
3. Run a guest with an additional scratch disk, i.e. with additional
arguments
-drive if=none,id=scratch-drive,format=raw,werror=stop,file=blkdebug:blkdebug.conf:scratch.img
-device virtio-blk-pci,id=scratch,drive=scratch-drive
The blkdebug part makes all writes to the scratch drive fail with
EIO. The werror=stop pauses the guest on write errors.
4. Connect to the QMP socket e.g. like this:
$ socat UNIX:/your/qmp/socket READLINE,history=$HOME/.qmp_history,prompt='QMP> '
Issue QMP command 'qmp_capabilities':
QMP> { "execute": "qmp_capabilities" }
5. Boot the guest.
6. In the guest, write to the scratch disk, e.g. like this:
# dd if=/dev/zero of=/dev/vdb count=1
Do double-check the device specified with of= is actually the
scratch device!
7. Issue QMP command 'cont':
QMP> { "execute": "cont" }
After step 6, I get a BLOCK_IO_ERROR event followed by a STOP event. Good.
After step 7, I get BLOCK_IO_ERROR, then RESUME, then STOP. Not so
good; I'd expect RESUME, then BLOCK_IO_ERROR, then STOP.
The funny event order confuses libvirt: virsh -r domstate DOMAIN
--reason reports "paused (unknown)" rather than "paused (I/O error)".
The culprit is vm_prepare_start().
/* Ensure that a STOP/RESUME pair of events is emitted if a
* vmstop request was pending. The BLOCK_IO_ERROR event, for
* example, according to documentation is always followed by
* the STOP event.
*/
if (runstate_is_running()) {
qapi_event_send_stop(&error_abort);
res = -1;
} else {
replay_enable_events();
cpu_enable_ticks();
runstate_set(RUN_STATE_RUNNING);
vm_state_notify(1, RUN_STATE_RUNNING);
}
/* We are sending this now, but the CPUs will be resumed shortly later */
qapi_event_send_resume(&error_abort);
return res;
When resuming a stopped guest, we take the else branch before we get
to sending RESUME. vm_state_notify() runs virtio_vmstate_change(),
among other things. This restarts I/O, triggering the BLOCK_IO_ERROR
event.
Reshuffle vm_prepare_start() to send the RESUME event earlier.
Fixes RHBZ 1566153.
Cc: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-Id: <20180423084518.2426-1-armbru@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2018-04-23 10:45:18 +02:00
|
|
|
|
|
|
|
replay_enable_events();
|
|
|
|
cpu_enable_ticks();
|
|
|
|
runstate_set(RUN_STATE_RUNNING);
|
|
|
|
vm_state_notify(1, RUN_STATE_RUNNING);
|
|
|
|
return 0;
|
2017-02-14 18:07:47 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void vm_start(void)
|
|
|
|
{
|
|
|
|
if (!vm_prepare_start()) {
|
|
|
|
resume_all_vcpus();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-14 16:18:09 +02:00
|
|
|
/* does a state transition even if the VM is already stopped,
|
|
|
|
current state is forgotten forever */
|
2013-07-05 13:49:54 +02:00
|
|
|
int vm_stop_force_state(RunState state)
|
2011-10-14 16:18:09 +02:00
|
|
|
{
|
|
|
|
if (runstate_is_running()) {
|
2013-07-05 13:49:54 +02:00
|
|
|
return vm_stop(state);
|
2011-10-14 16:18:09 +02:00
|
|
|
} else {
|
|
|
|
runstate_set(state);
|
2015-11-20 10:34:38 +01:00
|
|
|
|
|
|
|
bdrv_drain_all();
|
2013-07-18 14:52:19 +02:00
|
|
|
/* Make sure to return an error if the flush in a previous vm_stop()
|
|
|
|
* failed. */
|
2016-09-23 03:45:51 +02:00
|
|
|
return bdrv_flush_all();
|
2011-10-14 16:18:09 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-10-22 23:03:33 +02:00
|
|
|
void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
|
2010-05-04 21:55:35 +02:00
|
|
|
{
|
|
|
|
/* XXX: implement xxx_cpu_list for targets that still miss it */
|
2012-09-05 22:41:08 +02:00
|
|
|
#if defined(cpu_list)
|
|
|
|
cpu_list(f, cpu_fprintf);
|
2010-05-04 21:55:35 +02:00
|
|
|
#endif
|
|
|
|
}
|
2011-09-21 21:38:35 +02:00
|
|
|
|
|
|
|
CpuInfoList *qmp_query_cpus(Error **errp)
|
|
|
|
{
|
2017-05-10 13:29:55 +02:00
|
|
|
MachineState *ms = MACHINE(qdev_get_machine());
|
|
|
|
MachineClass *mc = MACHINE_GET_CLASS(ms);
|
2011-09-21 21:38:35 +02:00
|
|
|
CpuInfoList *head = NULL, *cur_item = NULL;
|
2013-05-29 22:29:20 +02:00
|
|
|
CPUState *cpu;
|
2011-09-21 21:38:35 +02:00
|
|
|
|
2013-06-24 23:50:24 +02:00
|
|
|
CPU_FOREACH(cpu) {
|
2011-09-21 21:38:35 +02:00
|
|
|
CpuInfoList *info;
|
2013-05-29 22:29:20 +02:00
|
|
|
#if defined(TARGET_I386)
|
|
|
|
X86CPU *x86_cpu = X86_CPU(cpu);
|
|
|
|
CPUX86State *env = &x86_cpu->env;
|
|
|
|
#elif defined(TARGET_PPC)
|
|
|
|
PowerPCCPU *ppc_cpu = POWERPC_CPU(cpu);
|
|
|
|
CPUPPCState *env = &ppc_cpu->env;
|
|
|
|
#elif defined(TARGET_SPARC)
|
|
|
|
SPARCCPU *sparc_cpu = SPARC_CPU(cpu);
|
|
|
|
CPUSPARCState *env = &sparc_cpu->env;
|
2018-03-02 13:32:59 +01:00
|
|
|
#elif defined(TARGET_RISCV)
|
|
|
|
RISCVCPU *riscv_cpu = RISCV_CPU(cpu);
|
|
|
|
CPURISCVState *env = &riscv_cpu->env;
|
2013-05-29 22:29:20 +02:00
|
|
|
#elif defined(TARGET_MIPS)
|
|
|
|
MIPSCPU *mips_cpu = MIPS_CPU(cpu);
|
|
|
|
CPUMIPSState *env = &mips_cpu->env;
|
2014-09-01 13:59:46 +02:00
|
|
|
#elif defined(TARGET_TRICORE)
|
|
|
|
TriCoreCPU *tricore_cpu = TRICORE_CPU(cpu);
|
|
|
|
CPUTriCoreState *env = &tricore_cpu->env;
|
qmp: expose s390-specific CPU info
Presently s390x is the only architecture not exposing specific
CPU information via QMP query-cpus. Upstream discussion has shown
that it could make sense to report the architecture specific CPU
state, e.g. to detect that a CPU has been stopped.
With this change the output of query-cpus will look like this on
s390:
[
{"arch": "s390", "current": true,
"props": {"core-id": 0}, "cpu-state": "operating", "CPU": 0,
"qom_path": "/machine/unattached/device[0]",
"halted": false, "thread_id": 63115},
{"arch": "s390", "current": false,
"props": {"core-id": 1}, "cpu-state": "stopped", "CPU": 1,
"qom_path": "/machine/unattached/device[1]",
"halted": true, "thread_id": 63116}
]
This change doesn't add the s390-specific data to HMP 'info cpus'.
A follow-on patch will remove all architecture specific information
from there.
Signed-off-by: Viktor Mihajlovski <mihajlov@linux.vnet.ibm.com>
Reviewed-by: David Hildenbrand <david@redhat.com>
Reviewed-by: Christian Borntraeger <borntraeger@de.ibm.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-Id: <1518797321-28356-2-git-send-email-mihajlov@linux.vnet.ibm.com>
Reviewed-by: Cornelia Huck <cohuck@redhat.com>
Signed-off-by: Cornelia Huck <cohuck@redhat.com>
2018-02-16 17:08:37 +01:00
|
|
|
#elif defined(TARGET_S390X)
|
|
|
|
S390CPU *s390_cpu = S390_CPU(cpu);
|
|
|
|
CPUS390XState *env = &s390_cpu->env;
|
2013-05-29 22:29:20 +02:00
|
|
|
#endif
|
2011-09-21 21:38:35 +02:00
|
|
|
|
2013-05-01 14:24:52 +02:00
|
|
|
cpu_synchronize_state(cpu);
|
2011-09-21 21:38:35 +02:00
|
|
|
|
|
|
|
info = g_malloc0(sizeof(*info));
|
|
|
|
info->value = g_malloc0(sizeof(*info->value));
|
2012-12-17 06:18:02 +01:00
|
|
|
info->value->CPU = cpu->cpu_index;
|
2013-05-29 22:29:20 +02:00
|
|
|
info->value->current = (cpu == first_cpu);
|
2013-01-17 18:51:17 +01:00
|
|
|
info->value->halted = cpu->halted;
|
2015-05-08 21:04:22 +02:00
|
|
|
info->value->qom_path = object_get_canonical_path(OBJECT(cpu));
|
2012-05-03 06:59:07 +02:00
|
|
|
info->value->thread_id = cpu->thread_id;
|
2011-09-21 21:38:35 +02:00
|
|
|
#if defined(TARGET_I386)
|
cpu: Convert CpuInfo into flat union
The CpuInfo struct is used only by the 'query-cpus' output
command, so we are free to modify it by adding fields (clients
are already supposed to ignore unknown output fields), or by
changing optional members to mandatory, while still keeping
QMP wire compatibility with older versions of qemu.
When qapi type CpuInfo was originally created for 0.14, we had
no notion of a flat union, and instead just listed a bunch of
optional fields with documentation about the mutually-exclusive
choice of which instruction pointer field(s) would be provided
for a given architecture. But now that we have flat unions and
introspection, it is better to segregate off which fields will
be provided according to the actual architecture. With this in
place, we no longer need the fields to be optional, because the
choice of the new 'arch' discriminator serves that role.
This has an additional benefit: the old all-in-one struct was
the only place in the code base that had a case-sensitive
naming of members 'pc' vs. 'PC'. Separating these spellings
into different branches of the flat union will allow us to add
restrictions against future case-insensitive collisions, since
that is generally a poor interface practice.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1447836791-369-25-git-send-email-eblake@redhat.com>
[Spelling of CPUInfo{SPARC,PPC,MIPS} fixed]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-11-18 09:52:59 +01:00
|
|
|
info->value->arch = CPU_INFO_ARCH_X86;
|
qapi: Don't box branches of flat unions
There's no reason to do two malloc's for a flat union; let's just
inline the branch struct directly into the C union branch of the
flat union.
Surprisingly, fewer clients were actually using explicit references
to the branch types in comparison to the number of flat unions
thus modified.
This lets us reduce the hack in qapi-types:gen_variants() added in
the previous patch; we no longer need to distinguish between
alternates and flat unions.
The change to unboxed structs means that u.data (added in commit
cee2dedb) is now coincident with random fields of each branch of
the flat union, whereas beforehand it was only coincident with
pointers (since all branches of a flat union have to be objects).
Note that this was already the case for simple unions - but there
we got lucky. Remember, visit_start_union() blindly returns true
for all visitors except for the dealloc visitor, where it returns
the value !!obj->u.data, and that this result then controls
whether to proceed with the visit to the variant. Pre-patch,
this meant that flat unions were testing whether the boxed pointer
was still NULL, and thereby skipping visit_end_implicit_struct()
and avoiding a NULL dereference if the pointer had not been
allocated. The same was true for simple unions where the current
branch had pointer type, except there we bypassed visit_type_FOO().
But for simple unions where the current branch had scalar type, the
contents of that scalar meant that the decision to call
visit_type_FOO() was data-dependent - the reason we got lucky there
is that visit_type_FOO() for all scalar types in the dealloc visitor
is a no-op (only the pointer variants had anything to free), so it
did not matter whether the dealloc visit was skipped. But with this
patch, we would risk leaking memory if we could skip a call to
visit_type_FOO_fields() based solely on a data-dependent decision.
But notice: in the dealloc visitor, visit_type_FOO() already handles
a NULL obj - it was only the visit_type_implicit_FOO() that was
failing to check for NULL. And now that we have refactored things to
have the branch be part of the parent struct, we no longer have a
separate pointer that can be NULL in the first place. So we can just
delete the call to visit_start_union() altogether, and blindly visit
the branch type; there is no change in behavior except to the dealloc
visitor, where we now unconditionally visit the branch, but where that
visit is now always safe (for a flat union, we can no longer
dereference NULL, and for a simple union, visit_type_FOO() was already
safely handling NULL on pointer types).
Unfortunately, simple unions are not as easy to switch to unboxed
layout; because we are special-casing the hidden implicit type with
a single 'data' member, we really DO need to keep calling another
layer of visit_start_struct(), with a second malloc; although there
are some cleanups planned for simple unions in later patches.
visit_start_union() and gen_visit_implicit_struct() are now unused.
Drop them.
Note that after this patch, the only remaining use of
visit_start_implicit_struct() is for alternate types; the next patch
will do further cleanup based on that fact.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1455778109-6278-14-git-send-email-eblake@redhat.com>
[Dead code deletion squashed in, commit message updated accordingly]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-02-18 07:48:27 +01:00
|
|
|
info->value->u.x86.pc = env->eip + env->segs[R_CS].base;
|
2011-09-21 21:38:35 +02:00
|
|
|
#elif defined(TARGET_PPC)
|
cpu: Convert CpuInfo into flat union
The CpuInfo struct is used only by the 'query-cpus' output
command, so we are free to modify it by adding fields (clients
are already supposed to ignore unknown output fields), or by
changing optional members to mandatory, while still keeping
QMP wire compatibility with older versions of qemu.
When qapi type CpuInfo was originally created for 0.14, we had
no notion of a flat union, and instead just listed a bunch of
optional fields with documentation about the mutually-exclusive
choice of which instruction pointer field(s) would be provided
for a given architecture. But now that we have flat unions and
introspection, it is better to segregate off which fields will
be provided according to the actual architecture. With this in
place, we no longer need the fields to be optional, because the
choice of the new 'arch' discriminator serves that role.
This has an additional benefit: the old all-in-one struct was
the only place in the code base that had a case-sensitive
naming of members 'pc' vs. 'PC'. Separating these spellings
into different branches of the flat union will allow us to add
restrictions against future case-insensitive collisions, since
that is generally a poor interface practice.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1447836791-369-25-git-send-email-eblake@redhat.com>
[Spelling of CPUInfo{SPARC,PPC,MIPS} fixed]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-11-18 09:52:59 +01:00
|
|
|
info->value->arch = CPU_INFO_ARCH_PPC;
|
qapi: Don't box branches of flat unions
There's no reason to do two malloc's for a flat union; let's just
inline the branch struct directly into the C union branch of the
flat union.
Surprisingly, fewer clients were actually using explicit references
to the branch types in comparison to the number of flat unions
thus modified.
This lets us reduce the hack in qapi-types:gen_variants() added in
the previous patch; we no longer need to distinguish between
alternates and flat unions.
The change to unboxed structs means that u.data (added in commit
cee2dedb) is now coincident with random fields of each branch of
the flat union, whereas beforehand it was only coincident with
pointers (since all branches of a flat union have to be objects).
Note that this was already the case for simple unions - but there
we got lucky. Remember, visit_start_union() blindly returns true
for all visitors except for the dealloc visitor, where it returns
the value !!obj->u.data, and that this result then controls
whether to proceed with the visit to the variant. Pre-patch,
this meant that flat unions were testing whether the boxed pointer
was still NULL, and thereby skipping visit_end_implicit_struct()
and avoiding a NULL dereference if the pointer had not been
allocated. The same was true for simple unions where the current
branch had pointer type, except there we bypassed visit_type_FOO().
But for simple unions where the current branch had scalar type, the
contents of that scalar meant that the decision to call
visit_type_FOO() was data-dependent - the reason we got lucky there
is that visit_type_FOO() for all scalar types in the dealloc visitor
is a no-op (only the pointer variants had anything to free), so it
did not matter whether the dealloc visit was skipped. But with this
patch, we would risk leaking memory if we could skip a call to
visit_type_FOO_fields() based solely on a data-dependent decision.
But notice: in the dealloc visitor, visit_type_FOO() already handles
a NULL obj - it was only the visit_type_implicit_FOO() that was
failing to check for NULL. And now that we have refactored things to
have the branch be part of the parent struct, we no longer have a
separate pointer that can be NULL in the first place. So we can just
delete the call to visit_start_union() altogether, and blindly visit
the branch type; there is no change in behavior except to the dealloc
visitor, where we now unconditionally visit the branch, but where that
visit is now always safe (for a flat union, we can no longer
dereference NULL, and for a simple union, visit_type_FOO() was already
safely handling NULL on pointer types).
Unfortunately, simple unions are not as easy to switch to unboxed
layout; because we are special-casing the hidden implicit type with
a single 'data' member, we really DO need to keep calling another
layer of visit_start_struct(), with a second malloc; although there
are some cleanups planned for simple unions in later patches.
visit_start_union() and gen_visit_implicit_struct() are now unused.
Drop them.
Note that after this patch, the only remaining use of
visit_start_implicit_struct() is for alternate types; the next patch
will do further cleanup based on that fact.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1455778109-6278-14-git-send-email-eblake@redhat.com>
[Dead code deletion squashed in, commit message updated accordingly]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-02-18 07:48:27 +01:00
|
|
|
info->value->u.ppc.nip = env->nip;
|
2011-09-21 21:38:35 +02:00
|
|
|
#elif defined(TARGET_SPARC)
|
cpu: Convert CpuInfo into flat union
The CpuInfo struct is used only by the 'query-cpus' output
command, so we are free to modify it by adding fields (clients
are already supposed to ignore unknown output fields), or by
changing optional members to mandatory, while still keeping
QMP wire compatibility with older versions of qemu.
When qapi type CpuInfo was originally created for 0.14, we had
no notion of a flat union, and instead just listed a bunch of
optional fields with documentation about the mutually-exclusive
choice of which instruction pointer field(s) would be provided
for a given architecture. But now that we have flat unions and
introspection, it is better to segregate off which fields will
be provided according to the actual architecture. With this in
place, we no longer need the fields to be optional, because the
choice of the new 'arch' discriminator serves that role.
This has an additional benefit: the old all-in-one struct was
the only place in the code base that had a case-sensitive
naming of members 'pc' vs. 'PC'. Separating these spellings
into different branches of the flat union will allow us to add
restrictions against future case-insensitive collisions, since
that is generally a poor interface practice.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1447836791-369-25-git-send-email-eblake@redhat.com>
[Spelling of CPUInfo{SPARC,PPC,MIPS} fixed]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-11-18 09:52:59 +01:00
|
|
|
info->value->arch = CPU_INFO_ARCH_SPARC;
|
qapi: Don't box branches of flat unions
There's no reason to do two malloc's for a flat union; let's just
inline the branch struct directly into the C union branch of the
flat union.
Surprisingly, fewer clients were actually using explicit references
to the branch types in comparison to the number of flat unions
thus modified.
This lets us reduce the hack in qapi-types:gen_variants() added in
the previous patch; we no longer need to distinguish between
alternates and flat unions.
The change to unboxed structs means that u.data (added in commit
cee2dedb) is now coincident with random fields of each branch of
the flat union, whereas beforehand it was only coincident with
pointers (since all branches of a flat union have to be objects).
Note that this was already the case for simple unions - but there
we got lucky. Remember, visit_start_union() blindly returns true
for all visitors except for the dealloc visitor, where it returns
the value !!obj->u.data, and that this result then controls
whether to proceed with the visit to the variant. Pre-patch,
this meant that flat unions were testing whether the boxed pointer
was still NULL, and thereby skipping visit_end_implicit_struct()
and avoiding a NULL dereference if the pointer had not been
allocated. The same was true for simple unions where the current
branch had pointer type, except there we bypassed visit_type_FOO().
But for simple unions where the current branch had scalar type, the
contents of that scalar meant that the decision to call
visit_type_FOO() was data-dependent - the reason we got lucky there
is that visit_type_FOO() for all scalar types in the dealloc visitor
is a no-op (only the pointer variants had anything to free), so it
did not matter whether the dealloc visit was skipped. But with this
patch, we would risk leaking memory if we could skip a call to
visit_type_FOO_fields() based solely on a data-dependent decision.
But notice: in the dealloc visitor, visit_type_FOO() already handles
a NULL obj - it was only the visit_type_implicit_FOO() that was
failing to check for NULL. And now that we have refactored things to
have the branch be part of the parent struct, we no longer have a
separate pointer that can be NULL in the first place. So we can just
delete the call to visit_start_union() altogether, and blindly visit
the branch type; there is no change in behavior except to the dealloc
visitor, where we now unconditionally visit the branch, but where that
visit is now always safe (for a flat union, we can no longer
dereference NULL, and for a simple union, visit_type_FOO() was already
safely handling NULL on pointer types).
Unfortunately, simple unions are not as easy to switch to unboxed
layout; because we are special-casing the hidden implicit type with
a single 'data' member, we really DO need to keep calling another
layer of visit_start_struct(), with a second malloc; although there
are some cleanups planned for simple unions in later patches.
visit_start_union() and gen_visit_implicit_struct() are now unused.
Drop them.
Note that after this patch, the only remaining use of
visit_start_implicit_struct() is for alternate types; the next patch
will do further cleanup based on that fact.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1455778109-6278-14-git-send-email-eblake@redhat.com>
[Dead code deletion squashed in, commit message updated accordingly]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-02-18 07:48:27 +01:00
|
|
|
info->value->u.q_sparc.pc = env->pc;
|
|
|
|
info->value->u.q_sparc.npc = env->npc;
|
2011-09-21 21:38:35 +02:00
|
|
|
#elif defined(TARGET_MIPS)
|
cpu: Convert CpuInfo into flat union
The CpuInfo struct is used only by the 'query-cpus' output
command, so we are free to modify it by adding fields (clients
are already supposed to ignore unknown output fields), or by
changing optional members to mandatory, while still keeping
QMP wire compatibility with older versions of qemu.
When qapi type CpuInfo was originally created for 0.14, we had
no notion of a flat union, and instead just listed a bunch of
optional fields with documentation about the mutually-exclusive
choice of which instruction pointer field(s) would be provided
for a given architecture. But now that we have flat unions and
introspection, it is better to segregate off which fields will
be provided according to the actual architecture. With this in
place, we no longer need the fields to be optional, because the
choice of the new 'arch' discriminator serves that role.
This has an additional benefit: the old all-in-one struct was
the only place in the code base that had a case-sensitive
naming of members 'pc' vs. 'PC'. Separating these spellings
into different branches of the flat union will allow us to add
restrictions against future case-insensitive collisions, since
that is generally a poor interface practice.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1447836791-369-25-git-send-email-eblake@redhat.com>
[Spelling of CPUInfo{SPARC,PPC,MIPS} fixed]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-11-18 09:52:59 +01:00
|
|
|
info->value->arch = CPU_INFO_ARCH_MIPS;
|
qapi: Don't box branches of flat unions
There's no reason to do two malloc's for a flat union; let's just
inline the branch struct directly into the C union branch of the
flat union.
Surprisingly, fewer clients were actually using explicit references
to the branch types in comparison to the number of flat unions
thus modified.
This lets us reduce the hack in qapi-types:gen_variants() added in
the previous patch; we no longer need to distinguish between
alternates and flat unions.
The change to unboxed structs means that u.data (added in commit
cee2dedb) is now coincident with random fields of each branch of
the flat union, whereas beforehand it was only coincident with
pointers (since all branches of a flat union have to be objects).
Note that this was already the case for simple unions - but there
we got lucky. Remember, visit_start_union() blindly returns true
for all visitors except for the dealloc visitor, where it returns
the value !!obj->u.data, and that this result then controls
whether to proceed with the visit to the variant. Pre-patch,
this meant that flat unions were testing whether the boxed pointer
was still NULL, and thereby skipping visit_end_implicit_struct()
and avoiding a NULL dereference if the pointer had not been
allocated. The same was true for simple unions where the current
branch had pointer type, except there we bypassed visit_type_FOO().
But for simple unions where the current branch had scalar type, the
contents of that scalar meant that the decision to call
visit_type_FOO() was data-dependent - the reason we got lucky there
is that visit_type_FOO() for all scalar types in the dealloc visitor
is a no-op (only the pointer variants had anything to free), so it
did not matter whether the dealloc visit was skipped. But with this
patch, we would risk leaking memory if we could skip a call to
visit_type_FOO_fields() based solely on a data-dependent decision.
But notice: in the dealloc visitor, visit_type_FOO() already handles
a NULL obj - it was only the visit_type_implicit_FOO() that was
failing to check for NULL. And now that we have refactored things to
have the branch be part of the parent struct, we no longer have a
separate pointer that can be NULL in the first place. So we can just
delete the call to visit_start_union() altogether, and blindly visit
the branch type; there is no change in behavior except to the dealloc
visitor, where we now unconditionally visit the branch, but where that
visit is now always safe (for a flat union, we can no longer
dereference NULL, and for a simple union, visit_type_FOO() was already
safely handling NULL on pointer types).
Unfortunately, simple unions are not as easy to switch to unboxed
layout; because we are special-casing the hidden implicit type with
a single 'data' member, we really DO need to keep calling another
layer of visit_start_struct(), with a second malloc; although there
are some cleanups planned for simple unions in later patches.
visit_start_union() and gen_visit_implicit_struct() are now unused.
Drop them.
Note that after this patch, the only remaining use of
visit_start_implicit_struct() is for alternate types; the next patch
will do further cleanup based on that fact.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1455778109-6278-14-git-send-email-eblake@redhat.com>
[Dead code deletion squashed in, commit message updated accordingly]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-02-18 07:48:27 +01:00
|
|
|
info->value->u.q_mips.PC = env->active_tc.PC;
|
2014-09-01 13:59:46 +02:00
|
|
|
#elif defined(TARGET_TRICORE)
|
cpu: Convert CpuInfo into flat union
The CpuInfo struct is used only by the 'query-cpus' output
command, so we are free to modify it by adding fields (clients
are already supposed to ignore unknown output fields), or by
changing optional members to mandatory, while still keeping
QMP wire compatibility with older versions of qemu.
When qapi type CpuInfo was originally created for 0.14, we had
no notion of a flat union, and instead just listed a bunch of
optional fields with documentation about the mutually-exclusive
choice of which instruction pointer field(s) would be provided
for a given architecture. But now that we have flat unions and
introspection, it is better to segregate off which fields will
be provided according to the actual architecture. With this in
place, we no longer need the fields to be optional, because the
choice of the new 'arch' discriminator serves that role.
This has an additional benefit: the old all-in-one struct was
the only place in the code base that had a case-sensitive
naming of members 'pc' vs. 'PC'. Separating these spellings
into different branches of the flat union will allow us to add
restrictions against future case-insensitive collisions, since
that is generally a poor interface practice.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1447836791-369-25-git-send-email-eblake@redhat.com>
[Spelling of CPUInfo{SPARC,PPC,MIPS} fixed]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-11-18 09:52:59 +01:00
|
|
|
info->value->arch = CPU_INFO_ARCH_TRICORE;
|
qapi: Don't box branches of flat unions
There's no reason to do two malloc's for a flat union; let's just
inline the branch struct directly into the C union branch of the
flat union.
Surprisingly, fewer clients were actually using explicit references
to the branch types in comparison to the number of flat unions
thus modified.
This lets us reduce the hack in qapi-types:gen_variants() added in
the previous patch; we no longer need to distinguish between
alternates and flat unions.
The change to unboxed structs means that u.data (added in commit
cee2dedb) is now coincident with random fields of each branch of
the flat union, whereas beforehand it was only coincident with
pointers (since all branches of a flat union have to be objects).
Note that this was already the case for simple unions - but there
we got lucky. Remember, visit_start_union() blindly returns true
for all visitors except for the dealloc visitor, where it returns
the value !!obj->u.data, and that this result then controls
whether to proceed with the visit to the variant. Pre-patch,
this meant that flat unions were testing whether the boxed pointer
was still NULL, and thereby skipping visit_end_implicit_struct()
and avoiding a NULL dereference if the pointer had not been
allocated. The same was true for simple unions where the current
branch had pointer type, except there we bypassed visit_type_FOO().
But for simple unions where the current branch had scalar type, the
contents of that scalar meant that the decision to call
visit_type_FOO() was data-dependent - the reason we got lucky there
is that visit_type_FOO() for all scalar types in the dealloc visitor
is a no-op (only the pointer variants had anything to free), so it
did not matter whether the dealloc visit was skipped. But with this
patch, we would risk leaking memory if we could skip a call to
visit_type_FOO_fields() based solely on a data-dependent decision.
But notice: in the dealloc visitor, visit_type_FOO() already handles
a NULL obj - it was only the visit_type_implicit_FOO() that was
failing to check for NULL. And now that we have refactored things to
have the branch be part of the parent struct, we no longer have a
separate pointer that can be NULL in the first place. So we can just
delete the call to visit_start_union() altogether, and blindly visit
the branch type; there is no change in behavior except to the dealloc
visitor, where we now unconditionally visit the branch, but where that
visit is now always safe (for a flat union, we can no longer
dereference NULL, and for a simple union, visit_type_FOO() was already
safely handling NULL on pointer types).
Unfortunately, simple unions are not as easy to switch to unboxed
layout; because we are special-casing the hidden implicit type with
a single 'data' member, we really DO need to keep calling another
layer of visit_start_struct(), with a second malloc; although there
are some cleanups planned for simple unions in later patches.
visit_start_union() and gen_visit_implicit_struct() are now unused.
Drop them.
Note that after this patch, the only remaining use of
visit_start_implicit_struct() is for alternate types; the next patch
will do further cleanup based on that fact.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1455778109-6278-14-git-send-email-eblake@redhat.com>
[Dead code deletion squashed in, commit message updated accordingly]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-02-18 07:48:27 +01:00
|
|
|
info->value->u.tricore.PC = env->PC;
|
qmp: expose s390-specific CPU info
Presently s390x is the only architecture not exposing specific
CPU information via QMP query-cpus. Upstream discussion has shown
that it could make sense to report the architecture specific CPU
state, e.g. to detect that a CPU has been stopped.
With this change the output of query-cpus will look like this on
s390:
[
{"arch": "s390", "current": true,
"props": {"core-id": 0}, "cpu-state": "operating", "CPU": 0,
"qom_path": "/machine/unattached/device[0]",
"halted": false, "thread_id": 63115},
{"arch": "s390", "current": false,
"props": {"core-id": 1}, "cpu-state": "stopped", "CPU": 1,
"qom_path": "/machine/unattached/device[1]",
"halted": true, "thread_id": 63116}
]
This change doesn't add the s390-specific data to HMP 'info cpus'.
A follow-on patch will remove all architecture specific information
from there.
Signed-off-by: Viktor Mihajlovski <mihajlov@linux.vnet.ibm.com>
Reviewed-by: David Hildenbrand <david@redhat.com>
Reviewed-by: Christian Borntraeger <borntraeger@de.ibm.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-Id: <1518797321-28356-2-git-send-email-mihajlov@linux.vnet.ibm.com>
Reviewed-by: Cornelia Huck <cohuck@redhat.com>
Signed-off-by: Cornelia Huck <cohuck@redhat.com>
2018-02-16 17:08:37 +01:00
|
|
|
#elif defined(TARGET_S390X)
|
|
|
|
info->value->arch = CPU_INFO_ARCH_S390;
|
|
|
|
info->value->u.s390.cpu_state = env->cpu_state;
|
2018-03-02 13:32:59 +01:00
|
|
|
#elif defined(TARGET_RISCV)
|
|
|
|
info->value->arch = CPU_INFO_ARCH_RISCV;
|
|
|
|
info->value->u.riscv.pc = env->pc;
|
cpu: Convert CpuInfo into flat union
The CpuInfo struct is used only by the 'query-cpus' output
command, so we are free to modify it by adding fields (clients
are already supposed to ignore unknown output fields), or by
changing optional members to mandatory, while still keeping
QMP wire compatibility with older versions of qemu.
When qapi type CpuInfo was originally created for 0.14, we had
no notion of a flat union, and instead just listed a bunch of
optional fields with documentation about the mutually-exclusive
choice of which instruction pointer field(s) would be provided
for a given architecture. But now that we have flat unions and
introspection, it is better to segregate off which fields will
be provided according to the actual architecture. With this in
place, we no longer need the fields to be optional, because the
choice of the new 'arch' discriminator serves that role.
This has an additional benefit: the old all-in-one struct was
the only place in the code base that had a case-sensitive
naming of members 'pc' vs. 'PC'. Separating these spellings
into different branches of the flat union will allow us to add
restrictions against future case-insensitive collisions, since
that is generally a poor interface practice.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1447836791-369-25-git-send-email-eblake@redhat.com>
[Spelling of CPUInfo{SPARC,PPC,MIPS} fixed]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-11-18 09:52:59 +01:00
|
|
|
#else
|
|
|
|
info->value->arch = CPU_INFO_ARCH_OTHER;
|
2011-09-21 21:38:35 +02:00
|
|
|
#endif
|
2017-05-10 13:29:55 +02:00
|
|
|
info->value->has_props = !!mc->cpu_index_to_instance_props;
|
|
|
|
if (info->value->has_props) {
|
|
|
|
CpuInstanceProperties *props;
|
|
|
|
props = g_malloc0(sizeof(*props));
|
|
|
|
*props = mc->cpu_index_to_instance_props(ms, cpu->cpu_index);
|
|
|
|
info->value->props = props;
|
|
|
|
}
|
2011-09-21 21:38:35 +02:00
|
|
|
|
|
|
|
/* XXX: waiting for the qapi to support GSList */
|
|
|
|
if (!cur_item) {
|
|
|
|
head = cur_item = info;
|
|
|
|
} else {
|
|
|
|
cur_item->next = info;
|
|
|
|
cur_item = info;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return head;
|
|
|
|
}
|
2011-11-22 19:32:37 +01:00
|
|
|
|
2018-04-27 21:28:51 +02:00
|
|
|
static CpuInfoArch sysemu_target_to_cpuinfo_arch(SysEmuTarget target)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* The @SysEmuTarget -> @CpuInfoArch mapping below is based on the
|
|
|
|
* TARGET_ARCH -> TARGET_BASE_ARCH mapping in the "configure" script.
|
|
|
|
*/
|
|
|
|
switch (target) {
|
|
|
|
case SYS_EMU_TARGET_I386:
|
|
|
|
case SYS_EMU_TARGET_X86_64:
|
|
|
|
return CPU_INFO_ARCH_X86;
|
|
|
|
|
|
|
|
case SYS_EMU_TARGET_PPC:
|
|
|
|
case SYS_EMU_TARGET_PPCEMB:
|
|
|
|
case SYS_EMU_TARGET_PPC64:
|
|
|
|
return CPU_INFO_ARCH_PPC;
|
|
|
|
|
|
|
|
case SYS_EMU_TARGET_SPARC:
|
|
|
|
case SYS_EMU_TARGET_SPARC64:
|
|
|
|
return CPU_INFO_ARCH_SPARC;
|
|
|
|
|
|
|
|
case SYS_EMU_TARGET_MIPS:
|
|
|
|
case SYS_EMU_TARGET_MIPSEL:
|
|
|
|
case SYS_EMU_TARGET_MIPS64:
|
|
|
|
case SYS_EMU_TARGET_MIPS64EL:
|
|
|
|
return CPU_INFO_ARCH_MIPS;
|
|
|
|
|
|
|
|
case SYS_EMU_TARGET_TRICORE:
|
|
|
|
return CPU_INFO_ARCH_TRICORE;
|
|
|
|
|
|
|
|
case SYS_EMU_TARGET_S390X:
|
|
|
|
return CPU_INFO_ARCH_S390;
|
|
|
|
|
|
|
|
case SYS_EMU_TARGET_RISCV32:
|
|
|
|
case SYS_EMU_TARGET_RISCV64:
|
|
|
|
return CPU_INFO_ARCH_RISCV;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return CPU_INFO_ARCH_OTHER;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void cpustate_to_cpuinfo_s390(CpuInfoS390 *info, const CPUState *cpu)
|
|
|
|
{
|
|
|
|
#ifdef TARGET_S390X
|
|
|
|
S390CPU *s390_cpu = S390_CPU(cpu);
|
|
|
|
CPUS390XState *env = &s390_cpu->env;
|
|
|
|
|
|
|
|
info->cpu_state = env->cpu_state;
|
|
|
|
#else
|
|
|
|
abort();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2018-02-16 17:08:38 +01:00
|
|
|
/*
|
|
|
|
* fast means: we NEVER interrupt vCPU threads to retrieve
|
|
|
|
* information from KVM.
|
|
|
|
*/
|
|
|
|
CpuInfoFastList *qmp_query_cpus_fast(Error **errp)
|
|
|
|
{
|
|
|
|
MachineState *ms = MACHINE(qdev_get_machine());
|
|
|
|
MachineClass *mc = MACHINE_GET_CLASS(ms);
|
|
|
|
CpuInfoFastList *head = NULL, *cur_item = NULL;
|
2018-04-27 21:28:51 +02:00
|
|
|
SysEmuTarget target = qapi_enum_parse(&SysEmuTarget_lookup, TARGET_NAME,
|
|
|
|
-1, &error_abort);
|
2018-02-16 17:08:38 +01:00
|
|
|
CPUState *cpu;
|
|
|
|
|
|
|
|
CPU_FOREACH(cpu) {
|
|
|
|
CpuInfoFastList *info = g_malloc0(sizeof(*info));
|
|
|
|
info->value = g_malloc0(sizeof(*info->value));
|
|
|
|
|
|
|
|
info->value->cpu_index = cpu->cpu_index;
|
|
|
|
info->value->qom_path = object_get_canonical_path(OBJECT(cpu));
|
|
|
|
info->value->thread_id = cpu->thread_id;
|
|
|
|
|
|
|
|
info->value->has_props = !!mc->cpu_index_to_instance_props;
|
|
|
|
if (info->value->has_props) {
|
|
|
|
CpuInstanceProperties *props;
|
|
|
|
props = g_malloc0(sizeof(*props));
|
|
|
|
*props = mc->cpu_index_to_instance_props(ms, cpu->cpu_index);
|
|
|
|
info->value->props = props;
|
|
|
|
}
|
|
|
|
|
2018-04-27 21:28:51 +02:00
|
|
|
info->value->arch = sysemu_target_to_cpuinfo_arch(target);
|
|
|
|
info->value->target = target;
|
|
|
|
if (target == SYS_EMU_TARGET_S390X) {
|
|
|
|
cpustate_to_cpuinfo_s390(&info->value->u.s390x, cpu);
|
|
|
|
}
|
|
|
|
|
2018-02-16 17:08:38 +01:00
|
|
|
if (!cur_item) {
|
|
|
|
head = cur_item = info;
|
|
|
|
} else {
|
|
|
|
cur_item->next = info;
|
|
|
|
cur_item = info;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return head;
|
|
|
|
}
|
|
|
|
|
2011-11-22 19:32:37 +01:00
|
|
|
void qmp_memsave(int64_t addr, int64_t size, const char *filename,
|
|
|
|
bool has_cpu, int64_t cpu_index, Error **errp)
|
|
|
|
{
|
|
|
|
FILE *f;
|
|
|
|
uint32_t l;
|
2012-12-17 06:18:02 +01:00
|
|
|
CPUState *cpu;
|
2011-11-22 19:32:37 +01:00
|
|
|
uint8_t buf[1024];
|
2015-02-08 13:14:38 +01:00
|
|
|
int64_t orig_addr = addr, orig_size = size;
|
2011-11-22 19:32:37 +01:00
|
|
|
|
|
|
|
if (!has_cpu) {
|
|
|
|
cpu_index = 0;
|
|
|
|
}
|
|
|
|
|
2013-02-15 15:41:49 +01:00
|
|
|
cpu = qemu_get_cpu(cpu_index);
|
|
|
|
if (cpu == NULL) {
|
2015-03-17 11:54:50 +01:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
|
|
|
|
"a CPU number");
|
2011-11-22 19:32:37 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
f = fopen(filename, "wb");
|
|
|
|
if (!f) {
|
2013-06-07 20:35:06 +02:00
|
|
|
error_setg_file_open(errp, errno, filename);
|
2011-11-22 19:32:37 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (size != 0) {
|
|
|
|
l = sizeof(buf);
|
|
|
|
if (l > size)
|
|
|
|
l = size;
|
2013-10-01 18:19:30 +02:00
|
|
|
if (cpu_memory_rw_debug(cpu, addr, buf, l, 0) != 0) {
|
2015-02-08 13:14:38 +01:00
|
|
|
error_setg(errp, "Invalid addr 0x%016" PRIx64 "/size %" PRId64
|
|
|
|
" specified", orig_addr, orig_size);
|
2013-10-01 18:19:30 +02:00
|
|
|
goto exit;
|
|
|
|
}
|
2011-11-22 19:32:37 +01:00
|
|
|
if (fwrite(buf, 1, l, f) != l) {
|
2015-03-17 11:54:50 +01:00
|
|
|
error_setg(errp, QERR_IO_ERROR);
|
2011-11-22 19:32:37 +01:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
addr += l;
|
|
|
|
size -= l;
|
|
|
|
}
|
|
|
|
|
|
|
|
exit:
|
|
|
|
fclose(f);
|
|
|
|
}
|
2011-11-22 20:26:46 +01:00
|
|
|
|
|
|
|
void qmp_pmemsave(int64_t addr, int64_t size, const char *filename,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
FILE *f;
|
|
|
|
uint32_t l;
|
|
|
|
uint8_t buf[1024];
|
|
|
|
|
|
|
|
f = fopen(filename, "wb");
|
|
|
|
if (!f) {
|
2013-06-07 20:35:06 +02:00
|
|
|
error_setg_file_open(errp, errno, filename);
|
2011-11-22 20:26:46 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (size != 0) {
|
|
|
|
l = sizeof(buf);
|
|
|
|
if (l > size)
|
|
|
|
l = size;
|
2014-04-07 20:28:23 +02:00
|
|
|
cpu_physical_memory_read(addr, buf, l);
|
2011-11-22 20:26:46 +01:00
|
|
|
if (fwrite(buf, 1, l, f) != l) {
|
2015-03-17 11:54:50 +01:00
|
|
|
error_setg(errp, QERR_IO_ERROR);
|
2011-11-22 20:26:46 +01:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
addr += l;
|
|
|
|
size -= l;
|
|
|
|
}
|
|
|
|
|
|
|
|
exit:
|
|
|
|
fclose(f);
|
|
|
|
}
|
2011-11-23 15:55:53 +01:00
|
|
|
|
|
|
|
void qmp_inject_nmi(Error **errp)
|
|
|
|
{
|
2014-08-20 14:16:33 +02:00
|
|
|
nmi_monitor_handle(monitor_get_cpu_index(), errp);
|
2011-11-23 15:55:53 +01:00
|
|
|
}
|
2014-07-25 11:56:33 +02:00
|
|
|
|
|
|
|
void dump_drift_info(FILE *f, fprintf_function cpu_fprintf)
|
|
|
|
{
|
|
|
|
if (!use_icount) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
cpu_fprintf(f, "Host - Guest clock %"PRIi64" ms\n",
|
|
|
|
(cpu_get_clock() - cpu_get_icount())/SCALE_MS);
|
|
|
|
if (icount_align_option) {
|
|
|
|
cpu_fprintf(f, "Max guest delay %"PRIi64" ms\n", -max_delay/SCALE_MS);
|
|
|
|
cpu_fprintf(f, "Max guest advance %"PRIi64" ms\n", max_advance/SCALE_MS);
|
|
|
|
} else {
|
|
|
|
cpu_fprintf(f, "Max guest delay NA\n");
|
|
|
|
cpu_fprintf(f, "Max guest advance NA\n");
|
|
|
|
}
|
|
|
|
}
|