yannick.naumann/RT-Task-Generator-QEMU
1
0
Fork 0
forked from alwin.berger/FRET-qemu
Code Pull Requests Activity

target/s390x/kvm: Simplify the GPRs, ACRs, CRs and prefix synchronization code

Browse Source 
KVM_SYNC_GPRS, KVM_SYNC_ACRS, KVM_SYNC_CRS and KVM_SYNC_PREFIX are
available since kernel 3.10. Since we already require at least kernel
3.15 in the s390x KVM code, we can also assume that the KVM_CAP_SYNC_REGS
sync code is always possible for these registers, and remove the
related checks and fallbacks via KVM_SET_REGS and KVM_GET_REGS.

Message-ID: <20231011080538.796999-3-thuth@redhat.com>
Signed-off-by: Thomas Huth <thuth@redhat.com>
This commit is contained in:
Thomas Huth 2023-10-11 10:05:38 +02:00
parent c35a79cbd7
commit 1d10716650
1 changed files with 24 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

106
target/s390x/kvm/kvm.c
View File

@ -139,7 +139,6 @@ const KVMCapabilityInfo kvm_arch_required_capabilities[] = {
KVM_CAP_LAST_INFO KVM_CAP_LAST_INFO
}; };
static int cap_sync_regs;
static int cap_async_pf; static int cap_async_pf;
static int cap_mem_op; static int cap_mem_op;
static int cap_mem_op_extension; static int cap_mem_op_extension;
@ -360,7 +359,6 @@ int kvm_arch_init(MachineState *ms, KVMState *s)
return -1; return -1;
} }
cap_sync_regs = true;
cap_async_pf = kvm_check_extension(s, KVM_CAP_ASYNC_PF); cap_async_pf = kvm_check_extension(s, KVM_CAP_ASYNC_PF);
cap_mem_op = kvm_check_extension(s, KVM_CAP_S390_MEM_OP); cap_mem_op = kvm_check_extension(s, KVM_CAP_S390_MEM_OP);
cap_mem_op_extension = kvm_check_extension(s, KVM_CAP_S390_MEM_OP_EXTENSION); cap_mem_op_extension = kvm_check_extension(s, KVM_CAP_S390_MEM_OP_EXTENSION);
@ -468,37 +466,28 @@ void kvm_s390_reset_vcpu_normal(S390CPU *cpu)
static int can_sync_regs(CPUState *cs, int regs) static int can_sync_regs(CPUState *cs, int regs)
{ {
return cap_sync_regs && (cs->kvm_run->kvm_valid_regs & regs) == regs; return (cs->kvm_run->kvm_valid_regs & regs) == regs;
} }
#define KVM_SYNC_REQUIRED_REGS (KVM_SYNC_GPRS | KVM_SYNC_ACRS | \
KVM_SYNC_CRS | KVM_SYNC_PREFIX)
int kvm_arch_put_registers(CPUState *cs, int level) int kvm_arch_put_registers(CPUState *cs, int level)
{ {
S390CPU *cpu = S390_CPU(cs); S390CPU *cpu = S390_CPU(cs);
CPUS390XState *env = &cpu->env; CPUS390XState *env = &cpu->env;
struct kvm_sregs sregs;
struct kvm_regs regs;
struct kvm_fpu fpu = {}; struct kvm_fpu fpu = {};
int r; int r;
int i; int i;
g_assert(can_sync_regs(cs, KVM_SYNC_REQUIRED_REGS));
/* always save the PSW and the GPRS*/ /* always save the PSW and the GPRS*/
cs->kvm_run->psw_addr = env->psw.addr; cs->kvm_run->psw_addr = env->psw.addr;
cs->kvm_run->psw_mask = env->psw.mask; cs->kvm_run->psw_mask = env->psw.mask;
if (can_sync_regs(cs, KVM_SYNC_GPRS)) { memcpy(cs->kvm_run->s.regs.gprs, env->regs, sizeof(cs->kvm_run->s.regs.gprs));
for (i = 0; i < 16; i++) { cs->kvm_run->kvm_dirty_regs |= KVM_SYNC_GPRS;
cs->kvm_run->s.regs.gprs[i] = env->regs[i];
cs->kvm_run->kvm_dirty_regs |= KVM_SYNC_GPRS;
}
} else {
for (i = 0; i < 16; i++) {
regs.gprs[i] = env->regs[i];
}
r = kvm_vcpu_ioctl(cs, KVM_SET_REGS, &regs);
if (r < 0) {
return r;
}
}
if (can_sync_regs(cs, KVM_SYNC_VRS)) { if (can_sync_regs(cs, KVM_SYNC_VRS)) {
for (i = 0; i < 32; i++) { for (i = 0; i < 32; i++) {
@ -531,6 +520,15 @@ int kvm_arch_put_registers(CPUState *cs, int level)
return 0; return 0;
} }
/*
* Access registers, control registers and the prefix - these are
* always available via kvm_sync_regs in the kernels that we support
*/
memcpy(cs->kvm_run->s.regs.acrs, env->aregs, sizeof(cs->kvm_run->s.regs.acrs));
memcpy(cs->kvm_run->s.regs.crs, env->cregs, sizeof(cs->kvm_run->s.regs.crs));
cs->kvm_run->s.regs.prefix = env->psa;
cs->kvm_run->kvm_dirty_regs |= KVM_SYNC_ACRS | KVM_SYNC_CRS | KVM_SYNC_PREFIX;
if (can_sync_regs(cs, KVM_SYNC_ARCH0)) { if (can_sync_regs(cs, KVM_SYNC_ARCH0)) {
cs->kvm_run->s.regs.cputm = env->cputm; cs->kvm_run->s.regs.cputm = env->cputm;
cs->kvm_run->s.regs.ckc = env->ckc; cs->kvm_run->s.regs.ckc = env->ckc;
@ -577,25 +575,6 @@ int kvm_arch_put_registers(CPUState *cs, int level)
} }
} }
/* access registers and control registers*/
if (can_sync_regs(cs, KVM_SYNC_ACRS | KVM_SYNC_CRS)) {
for (i = 0; i < 16; i++) {
cs->kvm_run->s.regs.acrs[i] = env->aregs[i];
cs->kvm_run->s.regs.crs[i] = env->cregs[i];
}
cs->kvm_run->kvm_dirty_regs |= KVM_SYNC_ACRS;
cs->kvm_run->kvm_dirty_regs |= KVM_SYNC_CRS;
} else {
for (i = 0; i < 16; i++) {
sregs.acrs[i] = env->aregs[i];
sregs.crs[i] = env->cregs[i];
}
r = kvm_vcpu_ioctl(cs, KVM_SET_SREGS, &sregs);
if (r < 0) {
return r;
}
}
if (can_sync_regs(cs, KVM_SYNC_GSCB)) { if (can_sync_regs(cs, KVM_SYNC_GSCB)) {
memcpy(cs->kvm_run->s.regs.gscb, env->gscb, 32); memcpy(cs->kvm_run->s.regs.gscb, env->gscb, 32);
cs->kvm_run->kvm_dirty_regs |= KVM_SYNC_GSCB; cs->kvm_run->kvm_dirty_regs |= KVM_SYNC_GSCB;
@ -617,13 +596,6 @@ int kvm_arch_put_registers(CPUState *cs, int level)
cs->kvm_run->kvm_dirty_regs |= KVM_SYNC_DIAG318; cs->kvm_run->kvm_dirty_regs |= KVM_SYNC_DIAG318;
} }
/* Finally the prefix */
if (can_sync_regs(cs, KVM_SYNC_PREFIX)) {
cs->kvm_run->s.regs.prefix = env->psa;
cs->kvm_run->kvm_dirty_regs |= KVM_SYNC_PREFIX;
} else {
/* prefix is only supported via sync regs */
}
return 0; return 0;
} }
@ -631,8 +603,6 @@ int kvm_arch_get_registers(CPUState *cs)
{ {
S390CPU *cpu = S390_CPU(cs); S390CPU *cpu = S390_CPU(cs);
CPUS390XState *env = &cpu->env; CPUS390XState *env = &cpu->env;
struct kvm_sregs sregs;
struct kvm_regs regs;
struct kvm_fpu fpu; struct kvm_fpu fpu;
int i, r; int i, r;
@ -640,37 +610,14 @@ int kvm_arch_get_registers(CPUState *cs)
env->psw.addr = cs->kvm_run->psw_addr; env->psw.addr = cs->kvm_run->psw_addr;
env->psw.mask = cs->kvm_run->psw_mask; env->psw.mask = cs->kvm_run->psw_mask;
/* the GPRS */ /* the GPRS, ACRS and CRS */
if (can_sync_regs(cs, KVM_SYNC_GPRS)) { g_assert(can_sync_regs(cs, KVM_SYNC_REQUIRED_REGS));
for (i = 0; i < 16; i++) { memcpy(env->regs, cs->kvm_run->s.regs.gprs, sizeof(env->regs));
env->regs[i] = cs->kvm_run->s.regs.gprs[i]; memcpy(env->aregs, cs->kvm_run->s.regs.acrs, sizeof(env->aregs));
} memcpy(env->cregs, cs->kvm_run->s.regs.crs, sizeof(env->cregs));
} else {
r = kvm_vcpu_ioctl(cs, KVM_GET_REGS, &regs);
if (r < 0) {
return r;
}
for (i = 0; i < 16; i++) {
env->regs[i] = regs.gprs[i];
}
}
/* The ACRS and CRS */ /* The prefix */
if (can_sync_regs(cs, KVM_SYNC_ACRS | KVM_SYNC_CRS)) { env->psa = cs->kvm_run->s.regs.prefix;
for (i = 0; i < 16; i++) {
env->aregs[i] = cs->kvm_run->s.regs.acrs[i];
env->cregs[i] = cs->kvm_run->s.regs.crs[i];
}
} else {
r = kvm_vcpu_ioctl(cs, KVM_GET_SREGS, &sregs);
if (r < 0) {
return r;
}
for (i = 0; i < 16; i++) {
env->aregs[i] = sregs.acrs[i];
env->cregs[i] = sregs.crs[i];
}
}
/* Floating point and vector registers */ /* Floating point and vector registers */
if (can_sync_regs(cs, KVM_SYNC_VRS)) { if (can_sync_regs(cs, KVM_SYNC_VRS)) {
@ -695,11 +642,6 @@ int kvm_arch_get_registers(CPUState *cs)
env->fpc = fpu.fpc; env->fpc = fpu.fpc;
} }
/* The prefix */
if (can_sync_regs(cs, KVM_SYNC_PREFIX)) {
env->psa = cs->kvm_run->s.regs.prefix;
}
if (can_sync_regs(cs, KVM_SYNC_ARCH0)) { if (can_sync_regs(cs, KVM_SYNC_ARCH0)) {
env->cputm = cs->kvm_run->s.regs.cputm; env->cputm = cs->kvm_run->s.regs.cputm;
env->ckc = cs->kvm_run->s.regs.ckc; env->ckc = cs->kvm_run->s.regs.ckc;