david.venhoff/QEMU-Nyx-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

kvm: Pass CPUState to kvm_vcpu_ioctl()

Browse Source 
Adapt helper functions to pass X86CPU / PowerPCCPU / S390CPU.

Signed-off-by: Andreas Färber <afaerber@suse.de>
This commit is contained in:
Andreas Färber 2012-10-31 06:06:49 +01:00
parent 20d695a925
commit 1bc22652d6
14 changed files with 188 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
hw/kvm/apic.c
View File

@ -104,7 +104,7 @@ static void kvm_apic_enable_tpr_reporting(APICCommonState *s, bool enable)
.enabled = enable .enabled = enable
}; };
kvm_vcpu_ioctl(&s->cpu->env, KVM_TPR_ACCESS_REPORTING, &ctl); kvm_vcpu_ioctl(CPU(s->cpu), KVM_TPR_ACCESS_REPORTING, &ctl);
} }
static void kvm_apic_vapic_base_update(APICCommonState *s) static void kvm_apic_vapic_base_update(APICCommonState *s)
@ -114,7 +114,7 @@ static void kvm_apic_vapic_base_update(APICCommonState *s)
}; };
int ret; int ret;
ret = kvm_vcpu_ioctl(&s->cpu->env, KVM_SET_VAPIC_ADDR, &vapid_addr); ret = kvm_vcpu_ioctl(CPU(s->cpu), KVM_SET_VAPIC_ADDR, &vapid_addr);
if (ret < 0) { if (ret < 0) {
fprintf(stderr, "KVM: setting VAPIC address failed (%s)\n", fprintf(stderr, "KVM: setting VAPIC address failed (%s)\n",
strerror(-ret)); strerror(-ret));
@ -125,15 +125,15 @@ static void kvm_apic_vapic_base_update(APICCommonState *s)
static void do_inject_external_nmi(void *data) static void do_inject_external_nmi(void *data)
{ {
APICCommonState *s = data; APICCommonState *s = data;
CPUX86State *env = &s->cpu->env; CPUState *cpu = CPU(s->cpu);
uint32_t lvt; uint32_t lvt;
int ret; int ret;
cpu_synchronize_state(env); cpu_synchronize_state(&s->cpu->env);
lvt = s->lvt[APIC_LVT_LINT1]; lvt = s->lvt[APIC_LVT_LINT1];
if (!(lvt & APIC_LVT_MASKED) && ((lvt >> 8) & 7) == APIC_DM_NMI) { if (!(lvt & APIC_LVT_MASKED) && ((lvt >> 8) & 7) == APIC_DM_NMI) {
ret = kvm_vcpu_ioctl(env, KVM_NMI); ret = kvm_vcpu_ioctl(cpu, KVM_NMI);
if (ret < 0) { if (ret < 0) {
fprintf(stderr, "KVM: injection failed, NMI lost (%s)\n", fprintf(stderr, "KVM: injection failed, NMI lost (%s)\n",
strerror(-ret)); strerror(-ret));

2
hw/kvm/clock.c
View File

@ -76,7 +76,7 @@ static void kvmclock_vm_state_change(void *opaque, int running,
return; return;
} }
for (penv = first_cpu; penv != NULL; penv = penv->next_cpu) { for (penv = first_cpu; penv != NULL; penv = penv->next_cpu) {
ret = kvm_vcpu_ioctl(penv, KVM_KVMCLOCK_CTRL, 0); ret = kvm_vcpu_ioctl(ENV_GET_CPU(penv), KVM_KVMCLOCK_CTRL, 0);
if (ret) { if (ret) {
if (ret != -EINVAL) { if (ret != -EINVAL) {
fprintf(stderr, "%s: %s\n", __func__, strerror(-ret)); fprintf(stderr, "%s: %s\n", __func__, strerror(-ret));

2
hw/ppc.c
View File

@ -65,7 +65,7 @@ void ppc_set_irq(CPUPPCState *env, int n_IRQ, int level)
if (old_pending != env->pending_interrupts) { if (old_pending != env->pending_interrupts) {
#ifdef CONFIG_KVM #ifdef CONFIG_KVM
kvmppc_set_interrupt(env, n_IRQ, level); kvmppc_set_interrupt(ppc_env_get_cpu(env), n_IRQ, level);
#endif #endif
} }

12
hw/s390-virtio-bus.c
View File

@ -111,10 +111,12 @@ VirtIOS390Bus *s390_virtio_bus_init(ram_addr_t *ram_size)
return bus; return bus;
} }
static void s390_virtio_irq(CPUS390XState *env, int config_change, uint64_t token) static void s390_virtio_irq(S390CPU *cpu, int config_change, uint64_t token)
{ {
CPUS390XState *env = &cpu->env;
if (kvm_enabled()) { if (kvm_enabled()) {
kvm_s390_virtio_irq(env, config_change, token); kvm_s390_virtio_irq(cpu, config_change, token);
} else { } else {
cpu_inject_ext(env, VIRTIO_EXT_CODE, config_change, token); cpu_inject_ext(env, VIRTIO_EXT_CODE, config_change, token);
} }
@ -143,8 +145,7 @@ static int s390_virtio_device_init(VirtIOS390Device *dev, VirtIODevice *vdev)
s390_virtio_reset_idx(dev); s390_virtio_reset_idx(dev);
if (dev->qdev.hotplugged) { if (dev->qdev.hotplugged) {
S390CPU *cpu = s390_cpu_addr2state(0); S390CPU *cpu = s390_cpu_addr2state(0);
CPUS390XState *env = &cpu->env; s390_virtio_irq(cpu, VIRTIO_PARAM_DEV_ADD, dev->dev_offs);
s390_virtio_irq(env, VIRTIO_PARAM_DEV_ADD, dev->dev_offs);
} }
return 0; return 0;
@ -369,9 +370,8 @@ static void virtio_s390_notify(void *opaque, uint16_t vector)
VirtIOS390Device *dev = (VirtIOS390Device*)opaque; VirtIOS390Device *dev = (VirtIOS390Device*)opaque;
uint64_t token = s390_virtio_device_vq_token(dev, vector); uint64_t token = s390_virtio_device_vq_token(dev, vector);
S390CPU *cpu = s390_cpu_addr2state(0); S390CPU *cpu = s390_cpu_addr2state(0);
CPUS390XState *env = &cpu->env;
s390_virtio_irq(env, 0, token); s390_virtio_irq(cpu, 0, token);
} }
static unsigned virtio_s390_get_features(void *opaque) static unsigned virtio_s390_get_features(void *opaque)

2
hw/spapr.c
View File

@ -797,7 +797,7 @@ static void ppc_spapr_init(QEMUMachineInitArgs *args)
/* Tell KVM that we're in PAPR mode */ /* Tell KVM that we're in PAPR mode */
if (kvm_enabled()) { if (kvm_enabled()) {
kvmppc_set_papr(env); kvmppc_set_papr(cpu);
} }
qemu_register_reset(spapr_cpu_reset, cpu); qemu_register_reset(spapr_cpu_reset, cpu);

14
kvm-all.c
View File

@ -1557,7 +1557,7 @@ int kvm_cpu_exec(CPUArchState *env)
} }
qemu_mutex_unlock_iothread(); qemu_mutex_unlock_iothread();
run_ret = kvm_vcpu_ioctl(env, KVM_RUN, 0); run_ret = kvm_vcpu_ioctl(cpu, KVM_RUN, 0);
qemu_mutex_lock_iothread(); qemu_mutex_lock_iothread();
kvm_arch_post_run(cpu, run); kvm_arch_post_run(cpu, run);
@ -1658,9 +1658,8 @@ int kvm_vm_ioctl(KVMState *s, int type, ...)
return ret; return ret;
} }
int kvm_vcpu_ioctl(CPUArchState *env, int type, ...) int kvm_vcpu_ioctl(CPUState *cpu, int type, ...)
{ {
CPUState *cpu = ENV_GET_CPU(env);
int ret; int ret;
void *arg; void *arg;
va_list ap; va_list ap;
@ -1791,9 +1790,9 @@ struct kvm_set_guest_debug_data {
static void kvm_invoke_set_guest_debug(void *data) static void kvm_invoke_set_guest_debug(void *data)
{ {
struct kvm_set_guest_debug_data *dbg_data = data; struct kvm_set_guest_debug_data *dbg_data = data;
CPUArchState *env = dbg_data->env; CPUState *cpu = ENV_GET_CPU(dbg_data->env);
dbg_data->err = kvm_vcpu_ioctl(env, KVM_SET_GUEST_DEBUG, &dbg_data->dbg); dbg_data->err = kvm_vcpu_ioctl(cpu, KVM_SET_GUEST_DEBUG, &dbg_data->dbg);
} }
int kvm_update_guest_debug(CPUArchState *env, unsigned long reinject_trap) int kvm_update_guest_debug(CPUArchState *env, unsigned long reinject_trap)
@ -1955,18 +1954,19 @@ void kvm_remove_all_breakpoints(CPUArchState *current_env)
int kvm_set_signal_mask(CPUArchState *env, const sigset_t *sigset) int kvm_set_signal_mask(CPUArchState *env, const sigset_t *sigset)
{ {
CPUState *cpu = ENV_GET_CPU(env);
struct kvm_signal_mask *sigmask; struct kvm_signal_mask *sigmask;
int r; int r;
if (!sigset) { if (!sigset) {
return kvm_vcpu_ioctl(env, KVM_SET_SIGNAL_MASK, NULL); return kvm_vcpu_ioctl(cpu, KVM_SET_SIGNAL_MASK, NULL);
} }
sigmask = g_malloc(sizeof(*sigmask) + sizeof(*sigset)); sigmask = g_malloc(sizeof(*sigmask) + sizeof(*sigset));
sigmask->len = 8; sigmask->len = 8;
memcpy(sigmask->sigset, sigset, sizeof(*sigset)); memcpy(sigmask->sigset, sigset, sizeof(*sigset));
r = kvm_vcpu_ioctl(env, KVM_SET_SIGNAL_MASK, sigmask); r = kvm_vcpu_ioctl(cpu, KVM_SET_SIGNAL_MASK, sigmask);
g_free(sigmask); g_free(sigmask);
return r; return r;

2
kvm.h
View File

@ -152,7 +152,7 @@ int kvm_ioctl(KVMState *s, int type, ...);
int kvm_vm_ioctl(KVMState *s, int type, ...); int kvm_vm_ioctl(KVMState *s, int type, ...);
int kvm_vcpu_ioctl(CPUArchState *env, int type, ...); int kvm_vcpu_ioctl(CPUState *cpu, int type, ...);
/* Arch specific hooks */ /* Arch specific hooks */

158
target-i386/kvm.c
View File

@ -368,8 +368,10 @@ int kvm_arch_on_sigbus(int code, void *addr)
return 0; return 0;
} }
static int kvm_inject_mce_oldstyle(CPUX86State *env) static int kvm_inject_mce_oldstyle(X86CPU *cpu)
{ {
CPUX86State *env = &cpu->env;
if (!kvm_has_vcpu_events() && env->exception_injected == EXCP12_MCHK) { if (!kvm_has_vcpu_events() && env->exception_injected == EXCP12_MCHK) {
unsigned int bank, bank_num = env->mcg_cap & 0xff; unsigned int bank, bank_num = env->mcg_cap & 0xff;
struct kvm_x86_mce mce; struct kvm_x86_mce mce;
@ -393,7 +395,7 @@ static int kvm_inject_mce_oldstyle(CPUX86State *env)
mce.addr = env->mce_banks[bank * 4 + 2]; mce.addr = env->mce_banks[bank * 4 + 2];
mce.misc = env->mce_banks[bank * 4 + 3]; mce.misc = env->mce_banks[bank * 4 + 3];
return kvm_vcpu_ioctl(env, KVM_X86_SET_MCE, &mce); return kvm_vcpu_ioctl(CPU(cpu), KVM_X86_SET_MCE, &mce);
} }
return 0; return 0;
} }
@ -593,7 +595,7 @@ int kvm_arch_init_vcpu(CPUState *cs)
} }
mcg_cap &= MCE_CAP_DEF; mcg_cap &= MCE_CAP_DEF;
mcg_cap |= banks; mcg_cap |= banks;
ret = kvm_vcpu_ioctl(env, KVM_X86_SETUP_MCE, &mcg_cap); ret = kvm_vcpu_ioctl(cs, KVM_X86_SETUP_MCE, &mcg_cap);
if (ret < 0) { if (ret < 0) {
fprintf(stderr, "KVM_X86_SETUP_MCE: %s", strerror(-ret)); fprintf(stderr, "KVM_X86_SETUP_MCE: %s", strerror(-ret));
return ret; return ret;
@ -605,14 +607,14 @@ int kvm_arch_init_vcpu(CPUState *cs)
qemu_add_vm_change_state_handler(cpu_update_state, env); qemu_add_vm_change_state_handler(cpu_update_state, env);
cpuid_data.cpuid.padding = 0; cpuid_data.cpuid.padding = 0;
r = kvm_vcpu_ioctl(env, KVM_SET_CPUID2, &cpuid_data); r = kvm_vcpu_ioctl(cs, KVM_SET_CPUID2, &cpuid_data);
if (r) { if (r) {
return r; return r;
} }
r = kvm_check_extension(env->kvm_state, KVM_CAP_TSC_CONTROL); r = kvm_check_extension(env->kvm_state, KVM_CAP_TSC_CONTROL);
if (r && env->tsc_khz) { if (r && env->tsc_khz) {
r = kvm_vcpu_ioctl(env, KVM_SET_TSC_KHZ, env->tsc_khz); r = kvm_vcpu_ioctl(cs, KVM_SET_TSC_KHZ, env->tsc_khz);
if (r < 0) { if (r < 0) {
fprintf(stderr, "KVM_SET_TSC_KHZ failed\n"); fprintf(stderr, "KVM_SET_TSC_KHZ failed\n");
return r; return r;
@ -820,13 +822,14 @@ static void kvm_getput_reg(__u64 *kvm_reg, target_ulong *qemu_reg, int set)
} }
} }
static int kvm_getput_regs(CPUX86State *env, int set) static int kvm_getput_regs(X86CPU *cpu, int set)
{ {
CPUX86State *env = &cpu->env;
struct kvm_regs regs; struct kvm_regs regs;
int ret = 0; int ret = 0;
if (!set) { if (!set) {
ret = kvm_vcpu_ioctl(env, KVM_GET_REGS, &regs); ret = kvm_vcpu_ioctl(CPU(cpu), KVM_GET_REGS, &regs);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -855,14 +858,15 @@ static int kvm_getput_regs(CPUX86State *env, int set)
kvm_getput_reg(&regs.rip, &env->eip, set); kvm_getput_reg(&regs.rip, &env->eip, set);
if (set) { if (set) {
ret = kvm_vcpu_ioctl(env, KVM_SET_REGS, &regs); ret = kvm_vcpu_ioctl(CPU(cpu), KVM_SET_REGS, &regs);
} }
return ret; return ret;
} }
static int kvm_put_fpu(CPUX86State *env) static int kvm_put_fpu(X86CPU *cpu)
{ {
CPUX86State *env = &cpu->env;
struct kvm_fpu fpu; struct kvm_fpu fpu;
int i; int i;
@ -880,7 +884,7 @@ static int kvm_put_fpu(CPUX86State *env)
memcpy(fpu.xmm, env->xmm_regs, sizeof env->xmm_regs); memcpy(fpu.xmm, env->xmm_regs, sizeof env->xmm_regs);
fpu.mxcsr = env->mxcsr; fpu.mxcsr = env->mxcsr;
return kvm_vcpu_ioctl(env, KVM_SET_FPU, &fpu); return kvm_vcpu_ioctl(CPU(cpu), KVM_SET_FPU, &fpu);
} }
#define XSAVE_FCW_FSW 0 #define XSAVE_FCW_FSW 0
@ -893,14 +897,15 @@ static int kvm_put_fpu(CPUX86State *env)
#define XSAVE_XSTATE_BV 128 #define XSAVE_XSTATE_BV 128
#define XSAVE_YMMH_SPACE 144 #define XSAVE_YMMH_SPACE 144
static int kvm_put_xsave(CPUX86State *env) static int kvm_put_xsave(X86CPU *cpu)
{ {
CPUX86State *env = &cpu->env;
struct kvm_xsave* xsave = env->kvm_xsave_buf; struct kvm_xsave* xsave = env->kvm_xsave_buf;
uint16_t cwd, swd, twd; uint16_t cwd, swd, twd;
int i, r; int i, r;
if (!kvm_has_xsave()) { if (!kvm_has_xsave()) {
return kvm_put_fpu(env); return kvm_put_fpu(cpu);
} }
memset(xsave, 0, sizeof(struct kvm_xsave)); memset(xsave, 0, sizeof(struct kvm_xsave));
@ -923,12 +928,13 @@ static int kvm_put_xsave(CPUX86State *env)
*(uint64_t *)&xsave->region[XSAVE_XSTATE_BV] = env->xstate_bv; *(uint64_t *)&xsave->region[XSAVE_XSTATE_BV] = env->xstate_bv;
memcpy(&xsave->region[XSAVE_YMMH_SPACE], env->ymmh_regs, memcpy(&xsave->region[XSAVE_YMMH_SPACE], env->ymmh_regs,
sizeof env->ymmh_regs); sizeof env->ymmh_regs);
r = kvm_vcpu_ioctl(env, KVM_SET_XSAVE, xsave); r = kvm_vcpu_ioctl(CPU(cpu), KVM_SET_XSAVE, xsave);
return r; return r;
} }
static int kvm_put_xcrs(CPUX86State *env) static int kvm_put_xcrs(X86CPU *cpu)
{ {
CPUX86State *env = &cpu->env;
struct kvm_xcrs xcrs; struct kvm_xcrs xcrs;
if (!kvm_has_xcrs()) { if (!kvm_has_xcrs()) {
@ -939,11 +945,12 @@ static int kvm_put_xcrs(CPUX86State *env)
xcrs.flags = 0; xcrs.flags = 0;
xcrs.xcrs[0].xcr = 0; xcrs.xcrs[0].xcr = 0;
xcrs.xcrs[0].value = env->xcr0; xcrs.xcrs[0].value = env->xcr0;
return kvm_vcpu_ioctl(env, KVM_SET_XCRS, &xcrs); return kvm_vcpu_ioctl(CPU(cpu), KVM_SET_XCRS, &xcrs);
} }
static int kvm_put_sregs(CPUX86State *env) static int kvm_put_sregs(X86CPU *cpu)
{ {
CPUX86State *env = &cpu->env;
struct kvm_sregs sregs; struct kvm_sregs sregs;
memset(sregs.interrupt_bitmap, 0, sizeof(sregs.interrupt_bitmap)); memset(sregs.interrupt_bitmap, 0, sizeof(sregs.interrupt_bitmap));
@ -988,7 +995,7 @@ static int kvm_put_sregs(CPUX86State *env)
sregs.efer = env->efer; sregs.efer = env->efer;
return kvm_vcpu_ioctl(env, KVM_SET_SREGS, &sregs); return kvm_vcpu_ioctl(CPU(cpu), KVM_SET_SREGS, &sregs);
} }
static void kvm_msr_entry_set(struct kvm_msr_entry *entry, static void kvm_msr_entry_set(struct kvm_msr_entry *entry,
@ -998,8 +1005,9 @@ static void kvm_msr_entry_set(struct kvm_msr_entry *entry,
entry->data = value; entry->data = value;
} }
static int kvm_put_msrs(CPUX86State *env, int level) static int kvm_put_msrs(X86CPU *cpu, int level)
{ {
CPUX86State *env = &cpu->env;
struct { struct {
struct kvm_msrs info; struct kvm_msrs info;
struct kvm_msr_entry entries[100]; struct kvm_msr_entry entries[100];
@ -1080,17 +1088,18 @@ static int kvm_put_msrs(CPUX86State *env, int level)
msr_data.info.nmsrs = n; msr_data.info.nmsrs = n;
return kvm_vcpu_ioctl(env, KVM_SET_MSRS, &msr_data); return kvm_vcpu_ioctl(CPU(cpu), KVM_SET_MSRS, &msr_data);
} }
static int kvm_get_fpu(CPUX86State *env) static int kvm_get_fpu(X86CPU *cpu)
{ {
CPUX86State *env = &cpu->env;
struct kvm_fpu fpu; struct kvm_fpu fpu;
int i, ret; int i, ret;
ret = kvm_vcpu_ioctl(env, KVM_GET_FPU, &fpu); ret = kvm_vcpu_ioctl(CPU(cpu), KVM_GET_FPU, &fpu);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -1111,17 +1120,18 @@ static int kvm_get_fpu(CPUX86State *env)
return 0; return 0;
} }
static int kvm_get_xsave(CPUX86State *env) static int kvm_get_xsave(X86CPU *cpu)
{ {
CPUX86State *env = &cpu->env;
struct kvm_xsave* xsave = env->kvm_xsave_buf; struct kvm_xsave* xsave = env->kvm_xsave_buf;
int ret, i; int ret, i;
uint16_t cwd, swd, twd; uint16_t cwd, swd, twd;
if (!kvm_has_xsave()) { if (!kvm_has_xsave()) {
return kvm_get_fpu(env); return kvm_get_fpu(cpu);
} }
ret = kvm_vcpu_ioctl(env, KVM_GET_XSAVE, xsave); ret = kvm_vcpu_ioctl(CPU(cpu), KVM_GET_XSAVE, xsave);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -1149,8 +1159,9 @@ static int kvm_get_xsave(CPUX86State *env)
return 0; return 0;
} }
static int kvm_get_xcrs(CPUX86State *env) static int kvm_get_xcrs(X86CPU *cpu)
{ {
CPUX86State *env = &cpu->env;
int i, ret; int i, ret;
struct kvm_xcrs xcrs; struct kvm_xcrs xcrs;
@ -1158,7 +1169,7 @@ static int kvm_get_xcrs(CPUX86State *env)
return 0; return 0;
} }
ret = kvm_vcpu_ioctl(env, KVM_GET_XCRS, &xcrs); ret = kvm_vcpu_ioctl(CPU(cpu), KVM_GET_XCRS, &xcrs);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -1173,13 +1184,14 @@ static int kvm_get_xcrs(CPUX86State *env)
return 0; return 0;
} }
static int kvm_get_sregs(CPUX86State *env) static int kvm_get_sregs(X86CPU *cpu)
{ {
CPUX86State *env = &cpu->env;
struct kvm_sregs sregs; struct kvm_sregs sregs;
uint32_t hflags; uint32_t hflags;
int bit, i, ret; int bit, i, ret;
ret = kvm_vcpu_ioctl(env, KVM_GET_SREGS, &sregs); ret = kvm_vcpu_ioctl(CPU(cpu), KVM_GET_SREGS, &sregs);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -1257,8 +1269,9 @@ static int kvm_get_sregs(CPUX86State *env)
return 0; return 0;
} }
static int kvm_get_msrs(CPUX86State *env) static int kvm_get_msrs(X86CPU *cpu)
{ {
CPUX86State *env = &cpu->env;
struct { struct {
struct kvm_msrs info; struct kvm_msrs info;
struct kvm_msr_entry entries[100]; struct kvm_msr_entry entries[100];
@ -1315,7 +1328,7 @@ static int kvm_get_msrs(CPUX86State *env)
} }
msr_data.info.nmsrs = n; msr_data.info.nmsrs = n;
ret = kvm_vcpu_ioctl(env, KVM_GET_MSRS, &msr_data); ret = kvm_vcpu_ioctl(CPU(cpu), KVM_GET_MSRS, &msr_data);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -1393,11 +1406,11 @@ static int kvm_get_msrs(CPUX86State *env)
return 0; return 0;
} }
static int kvm_put_mp_state(CPUX86State *env) static int kvm_put_mp_state(X86CPU *cpu)
{ {
struct kvm_mp_state mp_state = { .mp_state = env->mp_state }; struct kvm_mp_state mp_state = { .mp_state = cpu->env.mp_state };
return kvm_vcpu_ioctl(env, KVM_SET_MP_STATE, &mp_state); return kvm_vcpu_ioctl(CPU(cpu), KVM_SET_MP_STATE, &mp_state);
} }
static int kvm_get_mp_state(X86CPU *cpu) static int kvm_get_mp_state(X86CPU *cpu)
@ -1406,7 +1419,7 @@ static int kvm_get_mp_state(X86CPU *cpu)
struct kvm_mp_state mp_state; struct kvm_mp_state mp_state;
int ret; int ret;
ret = kvm_vcpu_ioctl(env, KVM_GET_MP_STATE, &mp_state); ret = kvm_vcpu_ioctl(CPU(cpu), KVM_GET_MP_STATE, &mp_state);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -1417,14 +1430,15 @@ static int kvm_get_mp_state(X86CPU *cpu)
return 0; return 0;
} }
static int kvm_get_apic(CPUX86State *env) static int kvm_get_apic(X86CPU *cpu)
{ {
CPUX86State *env = &cpu->env;
DeviceState *apic = env->apic_state; DeviceState *apic = env->apic_state;
struct kvm_lapic_state kapic; struct kvm_lapic_state kapic;
int ret; int ret;
if (apic && kvm_irqchip_in_kernel()) { if (apic && kvm_irqchip_in_kernel()) {
ret = kvm_vcpu_ioctl(env, KVM_GET_LAPIC, &kapic); ret = kvm_vcpu_ioctl(CPU(cpu), KVM_GET_LAPIC, &kapic);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -1434,21 +1448,23 @@ static int kvm_get_apic(CPUX86State *env)
return 0; return 0;
} }
static int kvm_put_apic(CPUX86State *env) static int kvm_put_apic(X86CPU *cpu)
{ {
CPUX86State *env = &cpu->env;
DeviceState *apic = env->apic_state; DeviceState *apic = env->apic_state;
struct kvm_lapic_state kapic; struct kvm_lapic_state kapic;
if (apic && kvm_irqchip_in_kernel()) { if (apic && kvm_irqchip_in_kernel()) {
kvm_put_apic_state(apic, &kapic); kvm_put_apic_state(apic, &kapic);
return kvm_vcpu_ioctl(env, KVM_SET_LAPIC, &kapic); return kvm_vcpu_ioctl(CPU(cpu), KVM_SET_LAPIC, &kapic);
} }
return 0; return 0;
} }
static int kvm_put_vcpu_events(CPUX86State *env, int level) static int kvm_put_vcpu_events(X86CPU *cpu, int level)
{ {
CPUX86State *env = &cpu->env;
struct kvm_vcpu_events events; struct kvm_vcpu_events events;
if (!kvm_has_vcpu_events()) { if (!kvm_has_vcpu_events()) {
@ -1478,11 +1494,12 @@ static int kvm_put_vcpu_events(CPUX86State *env, int level)
KVM_VCPUEVENT_VALID_NMI_PENDING | KVM_VCPUEVENT_VALID_SIPI_VECTOR; KVM_VCPUEVENT_VALID_NMI_PENDING | KVM_VCPUEVENT_VALID_SIPI_VECTOR;
} }
return kvm_vcpu_ioctl(env, KVM_SET_VCPU_EVENTS, &events); return kvm_vcpu_ioctl(CPU(cpu), KVM_SET_VCPU_EVENTS, &events);
} }
static int kvm_get_vcpu_events(CPUX86State *env) static int kvm_get_vcpu_events(X86CPU *cpu)
{ {
CPUX86State *env = &cpu->env;
struct kvm_vcpu_events events; struct kvm_vcpu_events events;
int ret; int ret;
@ -1490,7 +1507,7 @@ static int kvm_get_vcpu_events(CPUX86State *env)
return 0; return 0;
} }
ret = kvm_vcpu_ioctl(env, KVM_GET_VCPU_EVENTS, &events); ret = kvm_vcpu_ioctl(CPU(cpu), KVM_GET_VCPU_EVENTS, &events);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -1516,8 +1533,9 @@ static int kvm_get_vcpu_events(CPUX86State *env)
return 0; return 0;
} }
static int kvm_guest_debug_workarounds(CPUX86State *env) static int kvm_guest_debug_workarounds(X86CPU *cpu)
{ {
CPUX86State *env = &cpu->env;
int ret = 0; int ret = 0;
unsigned long reinject_trap = 0; unsigned long reinject_trap = 0;
@ -1545,8 +1563,9 @@ static int kvm_guest_debug_workarounds(CPUX86State *env)
return ret; return ret;
} }
static int kvm_put_debugregs(CPUX86State *env) static int kvm_put_debugregs(X86CPU *cpu)
{ {
CPUX86State *env = &cpu->env;
struct kvm_debugregs dbgregs; struct kvm_debugregs dbgregs;
int i; int i;
@ -1561,11 +1580,12 @@ static int kvm_put_debugregs(CPUX86State *env)
dbgregs.dr7 = env->dr[7]; dbgregs.dr7 = env->dr[7];
dbgregs.flags = 0; dbgregs.flags = 0;
return kvm_vcpu_ioctl(env, KVM_SET_DEBUGREGS, &dbgregs); return kvm_vcpu_ioctl(CPU(cpu), KVM_SET_DEBUGREGS, &dbgregs);
} }
static int kvm_get_debugregs(CPUX86State *env) static int kvm_get_debugregs(X86CPU *cpu)
{ {
CPUX86State *env = &cpu->env;
struct kvm_debugregs dbgregs; struct kvm_debugregs dbgregs;
int i, ret; int i, ret;
@ -1573,7 +1593,7 @@ static int kvm_get_debugregs(CPUX86State *env)
return 0; return 0;
} }
ret = kvm_vcpu_ioctl(env, KVM_GET_DEBUGREGS, &dbgregs); ret = kvm_vcpu_ioctl(CPU(cpu), KVM_GET_DEBUGREGS, &dbgregs);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -1589,56 +1609,55 @@ static int kvm_get_debugregs(CPUX86State *env)
int kvm_arch_put_registers(CPUState *cpu, int level) int kvm_arch_put_registers(CPUState *cpu, int level)
{ {
X86CPU *x86_cpu = X86_CPU(cpu); X86CPU *x86_cpu = X86_CPU(cpu);
CPUX86State *env = &x86_cpu->env;
int ret; int ret;
assert(cpu_is_stopped(cpu) || qemu_cpu_is_self(cpu)); assert(cpu_is_stopped(cpu) || qemu_cpu_is_self(cpu));
ret = kvm_getput_regs(env, 1); ret = kvm_getput_regs(x86_cpu, 1);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
ret = kvm_put_xsave(env); ret = kvm_put_xsave(x86_cpu);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
ret = kvm_put_xcrs(env); ret = kvm_put_xcrs(x86_cpu);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
ret = kvm_put_sregs(env); ret = kvm_put_sregs(x86_cpu);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
/* must be before kvm_put_msrs */ /* must be before kvm_put_msrs */
ret = kvm_inject_mce_oldstyle(env); ret = kvm_inject_mce_oldstyle(x86_cpu);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
ret = kvm_put_msrs(env, level); ret = kvm_put_msrs(x86_cpu, level);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
if (level >= KVM_PUT_RESET_STATE) { if (level >= KVM_PUT_RESET_STATE) {
ret = kvm_put_mp_state(env); ret = kvm_put_mp_state(x86_cpu);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
ret = kvm_put_apic(env); ret = kvm_put_apic(x86_cpu);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
} }
ret = kvm_put_vcpu_events(env, level); ret = kvm_put_vcpu_events(x86_cpu, level);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
ret = kvm_put_debugregs(env); ret = kvm_put_debugregs(x86_cpu);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
/* must be last */ /* must be last */
ret = kvm_guest_debug_workarounds(env); ret = kvm_guest_debug_workarounds(x86_cpu);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -1648,28 +1667,27 @@ int kvm_arch_put_registers(CPUState *cpu, int level)
int kvm_arch_get_registers(CPUState *cs) int kvm_arch_get_registers(CPUState *cs)
{ {
X86CPU *cpu = X86_CPU(cs); X86CPU *cpu = X86_CPU(cs);
CPUX86State *env = &cpu->env;
int ret; int ret;
assert(cpu_is_stopped(cs) || qemu_cpu_is_self(cs)); assert(cpu_is_stopped(cs) || qemu_cpu_is_self(cs));
ret = kvm_getput_regs(env, 0); ret = kvm_getput_regs(cpu, 0);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
ret = kvm_get_xsave(env); ret = kvm_get_xsave(cpu);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
ret = kvm_get_xcrs(env); ret = kvm_get_xcrs(cpu);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
ret = kvm_get_sregs(env); ret = kvm_get_sregs(cpu);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
ret = kvm_get_msrs(env); ret = kvm_get_msrs(cpu);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -1677,15 +1695,15 @@ int kvm_arch_get_registers(CPUState *cs)
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
ret = kvm_get_apic(env); ret = kvm_get_apic(cpu);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
ret = kvm_get_vcpu_events(env); ret = kvm_get_vcpu_events(cpu);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
ret = kvm_get_debugregs(env); ret = kvm_get_debugregs(cpu);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -1702,7 +1720,7 @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run)
if (env->interrupt_request & CPU_INTERRUPT_NMI) { if (env->interrupt_request & CPU_INTERRUPT_NMI) {
env->interrupt_request &= ~CPU_INTERRUPT_NMI; env->interrupt_request &= ~CPU_INTERRUPT_NMI;
DPRINTF("injected NMI\n"); DPRINTF("injected NMI\n");
ret = kvm_vcpu_ioctl(env, KVM_NMI); ret = kvm_vcpu_ioctl(cpu, KVM_NMI);
if (ret < 0) { if (ret < 0) {
fprintf(stderr, "KVM: injection failed, NMI lost (%s)\n", fprintf(stderr, "KVM: injection failed, NMI lost (%s)\n",
strerror(-ret)); strerror(-ret));
@ -1730,7 +1748,7 @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run)
intr.irq = irq; intr.irq = irq;
DPRINTF("injected interrupt %d\n", irq); DPRINTF("injected interrupt %d\n", irq);
ret = kvm_vcpu_ioctl(env, KVM_INTERRUPT, &intr); ret = kvm_vcpu_ioctl(cpu, KVM_INTERRUPT, &intr);
if (ret < 0) { if (ret < 0) {
fprintf(stderr, fprintf(stderr,
"KVM: injection failed, interrupt lost (%s)\n", "KVM: injection failed, interrupt lost (%s)\n",

55
target-ppc/kvm.c
View File

@ -99,8 +99,10 @@ int kvm_arch_init(KVMState *s)
return 0; return 0;
} }
static int kvm_arch_sync_sregs(CPUPPCState *cenv) static int kvm_arch_sync_sregs(PowerPCCPU *cpu)
{ {
CPUPPCState *cenv = &cpu->env;
CPUState *cs = CPU(cpu);
struct kvm_sregs sregs; struct kvm_sregs sregs;
int ret; int ret;
@ -117,18 +119,20 @@ static int kvm_arch_sync_sregs(CPUPPCState *cenv)
} }
} }
ret = kvm_vcpu_ioctl(cenv, KVM_GET_SREGS, &sregs); ret = kvm_vcpu_ioctl(cs, KVM_GET_SREGS, &sregs);
if (ret) { if (ret) {
return ret; return ret;
} }
sregs.pvr = cenv->spr[SPR_PVR]; sregs.pvr = cenv->spr[SPR_PVR];
return kvm_vcpu_ioctl(cenv, KVM_SET_SREGS, &sregs); return kvm_vcpu_ioctl(cs, KVM_SET_SREGS, &sregs);
} }
/* Set up a shared TLB array with KVM */ /* Set up a shared TLB array with KVM */
static int kvm_booke206_tlb_init(CPUPPCState *env) static int kvm_booke206_tlb_init(PowerPCCPU *cpu)
{ {
CPUPPCState *env = &cpu->env;
CPUState *cs = CPU(cpu);
struct kvm_book3e_206_tlb_params params = {}; struct kvm_book3e_206_tlb_params params = {};
struct kvm_config_tlb cfg = {}; struct kvm_config_tlb cfg = {};
struct kvm_enable_cap encap = {}; struct kvm_enable_cap encap = {};
@ -161,7 +165,7 @@ static int kvm_booke206_tlb_init(CPUPPCState *env)
encap.cap = KVM_CAP_SW_TLB; encap.cap = KVM_CAP_SW_TLB;
encap.args[0] = (uintptr_t)&cfg; encap.args[0] = (uintptr_t)&cfg;
ret = kvm_vcpu_ioctl(env, KVM_ENABLE_CAP, &encap); ret = kvm_vcpu_ioctl(cs, KVM_ENABLE_CAP, &encap);
if (ret < 0) { if (ret < 0) {
fprintf(stderr, "%s: couldn't enable KVM_CAP_SW_TLB: %s\n", fprintf(stderr, "%s: couldn't enable KVM_CAP_SW_TLB: %s\n",
__func__, strerror(-ret)); __func__, strerror(-ret));
@ -385,7 +389,7 @@ int kvm_arch_init_vcpu(CPUState *cs)
kvm_fixup_page_sizes(cenv); kvm_fixup_page_sizes(cenv);
/* Synchronize sregs with kvm */ /* Synchronize sregs with kvm */
ret = kvm_arch_sync_sregs(cenv); ret = kvm_arch_sync_sregs(cpu);
if (ret) { if (ret) {
return ret; return ret;
} }
@ -395,7 +399,7 @@ int kvm_arch_init_vcpu(CPUState *cs)
/* Some targets support access to KVM's guest TLB. */ /* Some targets support access to KVM's guest TLB. */
switch (cenv->mmu_model) { switch (cenv->mmu_model) {
case POWERPC_MMU_BOOKE206: case POWERPC_MMU_BOOKE206:
ret = kvm_booke206_tlb_init(cenv); ret = kvm_booke206_tlb_init(cpu);
break; break;
default: default:
break; break;
@ -408,8 +412,10 @@ void kvm_arch_reset_vcpu(CPUState *cpu)
{ {
} }
static void kvm_sw_tlb_put(CPUPPCState *env) static void kvm_sw_tlb_put(PowerPCCPU *cpu)
{ {
CPUPPCState *env = &cpu->env;
CPUState *cs = CPU(cpu);
struct kvm_dirty_tlb dirty_tlb; struct kvm_dirty_tlb dirty_tlb;
unsigned char *bitmap; unsigned char *bitmap;
int ret; int ret;
@ -424,7 +430,7 @@ static void kvm_sw_tlb_put(CPUPPCState *env)
dirty_tlb.bitmap = (uintptr_t)bitmap; dirty_tlb.bitmap = (uintptr_t)bitmap;
dirty_tlb.num_dirty = env->nb_tlb; dirty_tlb.num_dirty = env->nb_tlb;
ret = kvm_vcpu_ioctl(env, KVM_DIRTY_TLB, &dirty_tlb); ret = kvm_vcpu_ioctl(cs, KVM_DIRTY_TLB, &dirty_tlb);
if (ret) { if (ret) {
fprintf(stderr, "%s: KVM_DIRTY_TLB: %s\n", fprintf(stderr, "%s: KVM_DIRTY_TLB: %s\n",
__func__, strerror(-ret)); __func__, strerror(-ret));
@ -441,9 +447,10 @@ int kvm_arch_put_registers(CPUState *cs, int level)
int ret; int ret;
int i; int i;
ret = kvm_vcpu_ioctl(env, KVM_GET_REGS, &regs); ret = kvm_vcpu_ioctl(cs, KVM_GET_REGS, &regs);
if (ret < 0) if (ret < 0) {
return ret; return ret;
}
regs.ctr = env->ctr; regs.ctr = env->ctr;
regs.lr = env->lr; regs.lr = env->lr;
@ -468,12 +475,12 @@ int kvm_arch_put_registers(CPUState *cs, int level)
for (i = 0;i < 32; i++) for (i = 0;i < 32; i++)
regs.gpr[i] = env->gpr[i]; regs.gpr[i] = env->gpr[i];
ret = kvm_vcpu_ioctl(env, KVM_SET_REGS, &regs); ret = kvm_vcpu_ioctl(cs, KVM_SET_REGS, &regs);
if (ret < 0) if (ret < 0)
return ret; return ret;
if (env->tlb_dirty) { if (env->tlb_dirty) {
kvm_sw_tlb_put(env); kvm_sw_tlb_put(cpu);
env->tlb_dirty = false; env->tlb_dirty = false;
} }
@ -506,7 +513,7 @@ int kvm_arch_put_registers(CPUState *cs, int level)
| env->IBAT[1][i]; | env->IBAT[1][i];
} }
ret = kvm_vcpu_ioctl(env, KVM_SET_SREGS, &sregs); ret = kvm_vcpu_ioctl(cs, KVM_SET_SREGS, &sregs);
if (ret) { if (ret) {
return ret; return ret;
} }
@ -519,7 +526,7 @@ int kvm_arch_put_registers(CPUState *cs, int level)
.addr = (uintptr_t) &hior, .addr = (uintptr_t) &hior,
}; };
ret = kvm_vcpu_ioctl(env, KVM_SET_ONE_REG, &reg); ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
if (ret) { if (ret) {
return ret; return ret;
} }
@ -537,7 +544,7 @@ int kvm_arch_get_registers(CPUState *cs)
uint32_t cr; uint32_t cr;
int i, ret; int i, ret;
ret = kvm_vcpu_ioctl(env, KVM_GET_REGS, &regs); ret = kvm_vcpu_ioctl(cs, KVM_GET_REGS, &regs);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -571,7 +578,7 @@ int kvm_arch_get_registers(CPUState *cs)
env->gpr[i] = regs.gpr[i]; env->gpr[i] = regs.gpr[i];
if (cap_booke_sregs) { if (cap_booke_sregs) {
ret = kvm_vcpu_ioctl(env, KVM_GET_SREGS, &sregs); ret = kvm_vcpu_ioctl(cs, KVM_GET_SREGS, &sregs);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -675,7 +682,7 @@ int kvm_arch_get_registers(CPUState *cs)
} }
if (cap_segstate) { if (cap_segstate) {
ret = kvm_vcpu_ioctl(env, KVM_GET_SREGS, &sregs); ret = kvm_vcpu_ioctl(cs, KVM_GET_SREGS, &sregs);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -707,7 +714,7 @@ int kvm_arch_get_registers(CPUState *cs)
return 0; return 0;
} }
int kvmppc_set_interrupt(CPUPPCState *env, int irq, int level) int kvmppc_set_interrupt(PowerPCCPU *cpu, int irq, int level)
{ {
unsigned virq = level ? KVM_INTERRUPT_SET_LEVEL : KVM_INTERRUPT_UNSET; unsigned virq = level ? KVM_INTERRUPT_SET_LEVEL : KVM_INTERRUPT_UNSET;
@ -719,7 +726,7 @@ int kvmppc_set_interrupt(CPUPPCState *env, int irq, int level)
return 0; return 0;
} }
kvm_vcpu_ioctl(env, KVM_INTERRUPT, &virq); kvm_vcpu_ioctl(CPU(cpu), KVM_INTERRUPT, &virq);
return 0; return 0;
} }
@ -753,7 +760,7 @@ void kvm_arch_pre_run(CPUState *cs, struct kvm_run *run)
irq = KVM_INTERRUPT_SET; irq = KVM_INTERRUPT_SET;
dprintf("injected interrupt %d\n", irq); dprintf("injected interrupt %d\n", irq);
r = kvm_vcpu_ioctl(env, KVM_INTERRUPT, &irq); r = kvm_vcpu_ioctl(cs, KVM_INTERRUPT, &irq);
if (r < 0) if (r < 0)
printf("cpu %d fail inject %x\n", env->cpu_index, irq); printf("cpu %d fail inject %x\n", env->cpu_index, irq);
@ -1007,13 +1014,15 @@ int kvmppc_get_hypercall(CPUPPCState *env, uint8_t *buf, int buf_len)
return 0; return 0;
} }
void kvmppc_set_papr(CPUPPCState *env) void kvmppc_set_papr(PowerPCCPU *cpu)
{ {
CPUPPCState *env = &cpu->env;
CPUState *cs = CPU(cpu);
struct kvm_enable_cap cap = {}; struct kvm_enable_cap cap = {};
int ret; int ret;
cap.cap = KVM_CAP_PPC_PAPR; cap.cap = KVM_CAP_PPC_PAPR;
ret = kvm_vcpu_ioctl(env, KVM_ENABLE_CAP, &cap); ret = kvm_vcpu_ioctl(cs, KVM_ENABLE_CAP, &cap);
if (ret) { if (ret) {
cpu_abort(env, "This KVM version does not support PAPR\n"); cpu_abort(env, "This KVM version does not support PAPR\n");

8
target-ppc/kvm_ppc.h
View File

@ -20,8 +20,8 @@ uint64_t kvmppc_get_clockfreq(void);
uint32_t kvmppc_get_vmx(void); uint32_t kvmppc_get_vmx(void);
uint32_t kvmppc_get_dfp(void); uint32_t kvmppc_get_dfp(void);
int kvmppc_get_hypercall(CPUPPCState *env, uint8_t *buf, int buf_len); int kvmppc_get_hypercall(CPUPPCState *env, uint8_t *buf, int buf_len);
int kvmppc_set_interrupt(CPUPPCState *env, int irq, int level); int kvmppc_set_interrupt(PowerPCCPU *cpu, int irq, int level);
void kvmppc_set_papr(CPUPPCState *env); void kvmppc_set_papr(PowerPCCPU *cpu);
int kvmppc_smt_threads(void); int kvmppc_smt_threads(void);
#ifndef CONFIG_USER_ONLY #ifndef CONFIG_USER_ONLY
off_t kvmppc_alloc_rma(const char *name, MemoryRegion *sysmem); off_t kvmppc_alloc_rma(const char *name, MemoryRegion *sysmem);
@ -65,12 +65,12 @@ static inline int kvmppc_read_segment_page_sizes(uint32_t *prop, int maxcells)
return -1; return -1;
} }
static inline int kvmppc_set_interrupt(CPUPPCState *env, int irq, int level) static inline int kvmppc_set_interrupt(PowerPCCPU *cpu, int irq, int level)
{ {
return -1; return -1;
} }
static inline void kvmppc_set_papr(CPUPPCState *env) static inline void kvmppc_set_papr(PowerPCCPU *cpu)
{ {
} }

12
target-s390x/cpu.h
View File

@ -296,21 +296,21 @@ void s390x_cpu_timer(void *opaque);
int s390_virtio_hypercall(CPUS390XState *env, uint64_t mem, uint64_t hypercall); int s390_virtio_hypercall(CPUS390XState *env, uint64_t mem, uint64_t hypercall);
#ifdef CONFIG_KVM #ifdef CONFIG_KVM
void kvm_s390_interrupt(CPUS390XState *env, int type, uint32_t code); void kvm_s390_interrupt(S390CPU *cpu, int type, uint32_t code);
void kvm_s390_virtio_irq(CPUS390XState *env, int config_change, uint64_t token); void kvm_s390_virtio_irq(S390CPU *cpu, int config_change, uint64_t token);
void kvm_s390_interrupt_internal(CPUS390XState *env, int type, uint32_t parm, void kvm_s390_interrupt_internal(S390CPU *cpu, int type, uint32_t parm,
uint64_t parm64, int vm); uint64_t parm64, int vm);
#else #else
static inline void kvm_s390_interrupt(CPUS390XState *env, int type, uint32_t code) static inline void kvm_s390_interrupt(S390CPU *cpu, int type, uint32_t code)
{ {
} }
static inline void kvm_s390_virtio_irq(CPUS390XState *env, int config_change, static inline void kvm_s390_virtio_irq(S390CPU *cpu, int config_change,
uint64_t token) uint64_t token)
{ {
} }
static inline void kvm_s390_interrupt_internal(CPUS390XState *env, int type, static inline void kvm_s390_interrupt_internal(S390CPU *cpu, int type,
uint32_t parm, uint64_t parm64, uint32_t parm, uint64_t parm64,
int vm) int vm)
{ {

3
target-s390x/interrupt.c
View File

@ -19,7 +19,8 @@ void s390_sclp_extint(uint32_t parm)
if (kvm_enabled()) { if (kvm_enabled()) {
#ifdef CONFIG_KVM #ifdef CONFIG_KVM
kvm_s390_interrupt_internal(env, KVM_S390_INT_SERVICE, parm, 0, 1); kvm_s390_interrupt_internal(dummy_cpu, KVM_S390_INT_SERVICE, parm,
0, 1);
#endif #endif
} else { } else {
env->psw.addr += 4; env->psw.addr += 4;

62
target-s390x/kvm.c
View File

@ -74,10 +74,9 @@ int kvm_arch_init(KVMState *s)
int kvm_arch_init_vcpu(CPUState *cpu) int kvm_arch_init_vcpu(CPUState *cpu)
{ {
CPUS390XState *env = &S390_CPU(cpu)->env;
int ret = 0; int ret = 0;
if (kvm_vcpu_ioctl(env, KVM_S390_INITIAL_RESET, NULL) < 0) { if (kvm_vcpu_ioctl(cpu, KVM_S390_INITIAL_RESET, NULL) < 0) {
perror("cannot init reset vcpu"); perror("cannot init reset vcpu");
} }
@ -111,7 +110,7 @@ int kvm_arch_put_registers(CPUState *cs, int level)
for (i = 0; i < 16; i++) { for (i = 0; i < 16; i++) {
regs.gprs[i] = env->regs[i]; regs.gprs[i] = env->regs[i];
} }
ret = kvm_vcpu_ioctl(env, KVM_SET_REGS, &regs); ret = kvm_vcpu_ioctl(cs, KVM_SET_REGS, &regs);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -136,7 +135,7 @@ int kvm_arch_put_registers(CPUState *cs, int level)
sregs.acrs[i] = env->aregs[i]; sregs.acrs[i] = env->aregs[i];
sregs.crs[i] = env->cregs[i]; sregs.crs[i] = env->cregs[i];
} }
ret = kvm_vcpu_ioctl(env, KVM_SET_SREGS, &sregs); ret = kvm_vcpu_ioctl(cs, KVM_SET_SREGS, &sregs);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -171,7 +170,7 @@ int kvm_arch_get_registers(CPUState *cs)
env->regs[i] = env->kvm_run->s.regs.gprs[i]; env->regs[i] = env->kvm_run->s.regs.gprs[i];
} }
} else { } else {
ret = kvm_vcpu_ioctl(env, KVM_GET_REGS, &regs); ret = kvm_vcpu_ioctl(cs, KVM_GET_REGS, &regs);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -189,7 +188,7 @@ int kvm_arch_get_registers(CPUState *cs)
env->cregs[i] = env->kvm_run->s.regs.crs[i]; env->cregs[i] = env->kvm_run->s.regs.crs[i];
} }
} else { } else {
ret = kvm_vcpu_ioctl(env, KVM_GET_SREGS, &sregs); ret = kvm_vcpu_ioctl(cs, KVM_GET_SREGS, &sregs);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
@ -289,9 +288,11 @@ int kvm_arch_process_async_events(CPUState *cs)
return cpu->env.halted; return cpu->env.halted;
} }
void kvm_s390_interrupt_internal(CPUS390XState *env, int type, uint32_t parm, void kvm_s390_interrupt_internal(S390CPU *cpu, int type, uint32_t parm,
uint64_t parm64, int vm) uint64_t parm64, int vm)
{ {
CPUS390XState *env = &cpu->env;
CPUState *cs = CPU(cpu);
struct kvm_s390_interrupt kvmint; struct kvm_s390_interrupt kvmint;
int r; int r;
@ -306,7 +307,7 @@ void kvm_s390_interrupt_internal(CPUS390XState *env, int type, uint32_t parm,
if (vm) { if (vm) {
r = kvm_vm_ioctl(env->kvm_state, KVM_S390_INTERRUPT, &kvmint); r = kvm_vm_ioctl(env->kvm_state, KVM_S390_INTERRUPT, &kvmint);
} else { } else {
r = kvm_vcpu_ioctl(env, KVM_S390_INTERRUPT, &kvmint); r = kvm_vcpu_ioctl(cs, KVM_S390_INTERRUPT, &kvmint);
} }
if (r < 0) { if (r < 0) {
@ -315,20 +316,20 @@ void kvm_s390_interrupt_internal(CPUS390XState *env, int type, uint32_t parm,
} }
} }
void kvm_s390_virtio_irq(CPUS390XState *env, int config_change, uint64_t token) void kvm_s390_virtio_irq(S390CPU *cpu, int config_change, uint64_t token)
{ {
kvm_s390_interrupt_internal(env, KVM_S390_INT_VIRTIO, config_change, kvm_s390_interrupt_internal(cpu, KVM_S390_INT_VIRTIO, config_change,
token, 1); token, 1);
} }
void kvm_s390_interrupt(CPUS390XState *env, int type, uint32_t code) void kvm_s390_interrupt(S390CPU *cpu, int type, uint32_t code)
{ {
kvm_s390_interrupt_internal(env, type, code, 0, 0); kvm_s390_interrupt_internal(cpu, type, code, 0, 0);
} }
static void enter_pgmcheck(CPUS390XState *env, uint16_t code) static void enter_pgmcheck(S390CPU *cpu, uint16_t code)
{ {
kvm_s390_interrupt(env, KVM_S390_PROGRAM_INT, code); kvm_s390_interrupt(cpu, KVM_S390_PROGRAM_INT, code);
} }
static inline void setcc(CPUS390XState *env, uint64_t cc) static inline void setcc(CPUS390XState *env, uint64_t cc)
@ -340,9 +341,10 @@ static inline void setcc(CPUS390XState *env, uint64_t cc)
env->psw.mask |= (cc & 3) << 44; env->psw.mask |= (cc & 3) << 44;
} }
static int kvm_sclp_service_call(CPUS390XState *env, struct kvm_run *run, static int kvm_sclp_service_call(S390CPU *cpu, struct kvm_run *run,
uint16_t ipbh0) uint16_t ipbh0)
{ {
CPUS390XState *env = &cpu->env;
uint32_t sccb; uint32_t sccb;
uint64_t code; uint64_t code;
int r = 0; int r = 0;
@ -353,14 +355,14 @@ static int kvm_sclp_service_call(CPUS390XState *env, struct kvm_run *run,
r = sclp_service_call(sccb, code); r = sclp_service_call(sccb, code);
if (r < 0) { if (r < 0) {
enter_pgmcheck(env, -r); enter_pgmcheck(cpu, -r);
} }
setcc(env, r); setcc(env, r);
return 0; return 0;
} }
static int handle_priv(CPUS390XState *env, struct kvm_run *run, uint8_t ipa1) static int handle_priv(S390CPU *cpu, struct kvm_run *run, uint8_t ipa1)
{ {
int r = 0; int r = 0;
uint16_t ipbh0 = (run->s390_sieic.ipb & 0xffff0000) >> 16; uint16_t ipbh0 = (run->s390_sieic.ipb & 0xffff0000) >> 16;
@ -368,7 +370,7 @@ static int handle_priv(CPUS390XState *env, struct kvm_run *run, uint8_t ipa1)
dprintf("KVM: PRIV: %d\n", ipa1); dprintf("KVM: PRIV: %d\n", ipa1);
switch (ipa1) { switch (ipa1) {
case PRIV_SCLP_CALL: case PRIV_SCLP_CALL:
r = kvm_sclp_service_call(env, run, ipbh0); r = kvm_sclp_service_call(cpu, run, ipbh0);
break; break;
default: default:
dprintf("KVM: unknown PRIV: 0x%x\n", ipa1); dprintf("KVM: unknown PRIV: 0x%x\n", ipa1);
@ -411,7 +413,7 @@ static int s390_cpu_restart(S390CPU *cpu)
{ {
CPUS390XState *env = &cpu->env; CPUS390XState *env = &cpu->env;
kvm_s390_interrupt(env, KVM_S390_RESTART, 0); kvm_s390_interrupt(cpu, KVM_S390_RESTART, 0);
s390_add_running_cpu(env); s390_add_running_cpu(env);
qemu_cpu_kick(CPU(cpu)); qemu_cpu_kick(CPU(cpu));
dprintf("DONE: SIGP cpu restart: %p\n", env); dprintf("DONE: SIGP cpu restart: %p\n", env);
@ -425,12 +427,13 @@ static int s390_store_status(CPUS390XState *env, uint32_t parameter)
return -1; return -1;
} }
static int s390_cpu_initial_reset(CPUS390XState *env) static int s390_cpu_initial_reset(S390CPU *cpu)
{ {
CPUS390XState *env = &cpu->env;
int i; int i;
s390_del_running_cpu(env); s390_del_running_cpu(env);
if (kvm_vcpu_ioctl(env, KVM_S390_INITIAL_RESET, NULL) < 0) { if (kvm_vcpu_ioctl(CPU(cpu), KVM_S390_INITIAL_RESET, NULL) < 0) {
perror("cannot init reset vcpu"); perror("cannot init reset vcpu");
} }
@ -489,7 +492,7 @@ static int handle_sigp(CPUS390XState *env, struct kvm_run *run, uint8_t ipa1)
/* make the caller panic */ /* make the caller panic */
return -1; return -1;
case SIGP_INITIAL_CPU_RESET: case SIGP_INITIAL_CPU_RESET:
r = s390_cpu_initial_reset(target_env); r = s390_cpu_initial_reset(target_cpu);
break; break;
default: default:
fprintf(stderr, "KVM: unknown SIGP: 0x%x\n", order_code); fprintf(stderr, "KVM: unknown SIGP: 0x%x\n", order_code);
@ -501,8 +504,9 @@ out:
return 0; return 0;
} }
static int handle_instruction(CPUS390XState *env, struct kvm_run *run) static int handle_instruction(S390CPU *cpu, struct kvm_run *run)
{ {
CPUS390XState *env = &cpu->env;
unsigned int ipa0 = (run->s390_sieic.ipa & 0xff00); unsigned int ipa0 = (run->s390_sieic.ipa & 0xff00);
uint8_t ipa1 = run->s390_sieic.ipa & 0x00ff; uint8_t ipa1 = run->s390_sieic.ipa & 0x00ff;
int ipb_code = (run->s390_sieic.ipb & 0x0fff0000) >> 16; int ipb_code = (run->s390_sieic.ipb & 0x0fff0000) >> 16;
@ -511,7 +515,7 @@ static int handle_instruction(CPUS390XState *env, struct kvm_run *run)
dprintf("handle_instruction 0x%x 0x%x\n", run->s390_sieic.ipa, run->s390_sieic.ipb); dprintf("handle_instruction 0x%x 0x%x\n", run->s390_sieic.ipa, run->s390_sieic.ipb);
switch (ipa0) { switch (ipa0) {
case IPA0_PRIV: case IPA0_PRIV:
r = handle_priv(env, run, ipa1); r = handle_priv(cpu, run, ipa1);
break; break;
case IPA0_DIAG: case IPA0_DIAG:
r = handle_diag(env, run, ipb_code); r = handle_diag(env, run, ipb_code);
@ -522,7 +526,7 @@ static int handle_instruction(CPUS390XState *env, struct kvm_run *run)
} }
if (r < 0) { if (r < 0) {
enter_pgmcheck(env, 0x0001); enter_pgmcheck(cpu, 0x0001);
} }
return 0; return 0;
} }
@ -533,8 +537,9 @@ static bool is_special_wait_psw(CPUS390XState *env)
return env->kvm_run->psw_addr == 0xfffUL; return env->kvm_run->psw_addr == 0xfffUL;
} }
static int handle_intercept(CPUS390XState *env) static int handle_intercept(S390CPU *cpu)
{ {
CPUS390XState *env = &cpu->env;
struct kvm_run *run = env->kvm_run; struct kvm_run *run = env->kvm_run;
int icpt_code = run->s390_sieic.icptcode; int icpt_code = run->s390_sieic.icptcode;
int r = 0; int r = 0;
@ -543,7 +548,7 @@ static int handle_intercept(CPUS390XState *env)
(long)env->kvm_run->psw_addr); (long)env->kvm_run->psw_addr);
switch (icpt_code) { switch (icpt_code) {
case ICPT_INSTRUCTION: case ICPT_INSTRUCTION:
r = handle_instruction(env, run); r = handle_instruction(cpu, run);
break; break;
case ICPT_WAITPSW: case ICPT_WAITPSW:
if (s390_del_running_cpu(env) == 0 && if (s390_del_running_cpu(env) == 0 &&
@ -578,12 +583,11 @@ static int handle_intercept(CPUS390XState *env)
int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run) int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run)
{ {
S390CPU *cpu = S390_CPU(cs); S390CPU *cpu = S390_CPU(cs);
CPUS390XState *env = &cpu->env;
int ret = 0; int ret = 0;
switch (run->exit_reason) { switch (run->exit_reason) {
case KVM_EXIT_S390_SIEIC: case KVM_EXIT_S390_SIEIC:
ret = handle_intercept(env); ret = handle_intercept(cpu);
break; break;
case KVM_EXIT_S390_RESET: case KVM_EXIT_S390_RESET:
qemu_system_reset_request(); qemu_system_reset_request();

2
target-s390x/misc_helper.c
View File

@ -57,7 +57,7 @@ void program_interrupt(CPUS390XState *env, uint32_t code, int ilc)
if (kvm_enabled()) { if (kvm_enabled()) {
#ifdef CONFIG_KVM #ifdef CONFIG_KVM
kvm_s390_interrupt(env, KVM_S390_PROGRAM_INT, code); kvm_s390_interrupt(s390_env_get_cpu(env), KVM_S390_PROGRAM_INT, code);
#endif #endif
} else { } else {
env->int_pgm_code = code; env->int_pgm_code = code;