ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

cpu: Move kvm_state field into CPUState 

Adapt some functions to take CPUState / {PowerPC,S390}CPU argument.

Signed-off-by: Andreas Färber <afaerber@suse.de>
This commit is contained in:
Andreas Färber 2012-12-01 05:35:08 +01:00
parent a34a92b9ec
commit a60f24b56b
8 changed files with 57 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cpu-defs.h
View File

@ -135,7 +135,6 @@ typedef struct icount_decr_u16 {
#endif #endif
struct kvm_run; struct kvm_run;
struct KVMState;
struct qemu_work_item; struct qemu_work_item;
typedef struct CPUBreakpoint { typedef struct CPUBreakpoint {
@ -205,7 +204,6 @@ typedef struct CPUWatchpoint {
void *opaque; \ void *opaque; \
\ \
const char *cpu_model_str; \ const char *cpu_model_str; \
struct KVMState *kvm_state; \
struct kvm_run *kvm_run; struct kvm_run *kvm_run;
#endif #endif

3
include/qemu/cpu.h
View File

@ -52,6 +52,8 @@ typedef struct CPUClass {
void (*reset)(CPUState *cpu); void (*reset)(CPUState *cpu);
} CPUClass; } CPUClass;
struct KVMState;
/** /**
* CPUState: * CPUState:
* @created: Indicates whether the CPU thread has been successfully created. * @created: Indicates whether the CPU thread has been successfully created.
@ -82,6 +84,7 @@ struct CPUState {
int kvm_fd; int kvm_fd;
bool kvm_vcpu_dirty; bool kvm_vcpu_dirty;
#endif #endif
struct KVMState *kvm_state;
/* TODO Move common fields from CPUArchState here. */ /* TODO Move common fields from CPUArchState here. */
}; };

28
kvm-all.c
View File

@ -230,7 +230,7 @@ int kvm_init_vcpu(CPUArchState *env)
} }
cpu->kvm_fd = ret; cpu->kvm_fd = ret;
env->kvm_state = s; cpu->kvm_state = s;
cpu->kvm_vcpu_dirty = true; cpu->kvm_vcpu_dirty = true;
mmap_size = kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, 0); mmap_size = kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, 0);
@ -1763,12 +1763,12 @@ void kvm_setup_guest_memory(void *start, size_t size)
} }
#ifdef KVM_CAP_SET_GUEST_DEBUG #ifdef KVM_CAP_SET_GUEST_DEBUG
struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUArchState *env, struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *cpu,
target_ulong pc) target_ulong pc)
{ {
struct kvm_sw_breakpoint *bp; struct kvm_sw_breakpoint *bp;
QTAILQ_FOREACH(bp, &env->kvm_state->kvm_sw_breakpoints, entry) { QTAILQ_FOREACH(bp, &cpu->kvm_state->kvm_sw_breakpoints, entry) {
if (bp->pc == pc) { if (bp->pc == pc) {
return bp; return bp;
} }
@ -1776,23 +1776,23 @@ struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUArchState *env,
return NULL; return NULL;
} }
int kvm_sw_breakpoints_active(CPUArchState *env) int kvm_sw_breakpoints_active(CPUState *cpu)
{ {
return !QTAILQ_EMPTY(&env->kvm_state->kvm_sw_breakpoints); return !QTAILQ_EMPTY(&cpu->kvm_state->kvm_sw_breakpoints);
} }
struct kvm_set_guest_debug_data { struct kvm_set_guest_debug_data {
struct kvm_guest_debug dbg; struct kvm_guest_debug dbg;
CPUArchState *env; CPUState *cpu;
int err; int err;
}; };
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;
CPUState *cpu = ENV_GET_CPU(dbg_data->env);
dbg_data->err = kvm_vcpu_ioctl(cpu, KVM_SET_GUEST_DEBUG, &dbg_data->dbg); dbg_data->err = kvm_vcpu_ioctl(dbg_data->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)
@ -1806,7 +1806,7 @@ int kvm_update_guest_debug(CPUArchState *env, unsigned long reinject_trap)
data.dbg.control |= KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_SINGLESTEP; data.dbg.control |= KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_SINGLESTEP;
} }
kvm_arch_update_guest_debug(cpu, &data.dbg); kvm_arch_update_guest_debug(cpu, &data.dbg);
data.env = env; data.cpu = cpu;
run_on_cpu(cpu, kvm_invoke_set_guest_debug, &data); run_on_cpu(cpu, kvm_invoke_set_guest_debug, &data);
return data.err; return data.err;
@ -1821,7 +1821,7 @@ int kvm_insert_breakpoint(CPUArchState *current_env, target_ulong addr,
int err; int err;
if (type == GDB_BREAKPOINT_SW) { if (type == GDB_BREAKPOINT_SW) {
bp = kvm_find_sw_breakpoint(current_env, addr); bp = kvm_find_sw_breakpoint(current_cpu, addr);
if (bp) { if (bp) {
bp->use_count++; bp->use_count++;
return 0; return 0;
@ -1840,7 +1840,7 @@ int kvm_insert_breakpoint(CPUArchState *current_env, target_ulong addr,
return err; return err;
} }
QTAILQ_INSERT_HEAD(&current_env->kvm_state->kvm_sw_breakpoints, QTAILQ_INSERT_HEAD(&current_cpu->kvm_state->kvm_sw_breakpoints,
bp, entry); bp, entry);
} else { } else {
err = kvm_arch_insert_hw_breakpoint(addr, len, type); err = kvm_arch_insert_hw_breakpoint(addr, len, type);
@ -1867,7 +1867,7 @@ int kvm_remove_breakpoint(CPUArchState *current_env, target_ulong addr,
int err; int err;
if (type == GDB_BREAKPOINT_SW) { if (type == GDB_BREAKPOINT_SW) {
bp = kvm_find_sw_breakpoint(current_env, addr); bp = kvm_find_sw_breakpoint(current_cpu, addr);
if (!bp) { if (!bp) {
return -ENOENT; return -ENOENT;
} }
@ -1882,7 +1882,7 @@ int kvm_remove_breakpoint(CPUArchState *current_env, target_ulong addr,
return err; return err;
} }
QTAILQ_REMOVE(&current_env->kvm_state->kvm_sw_breakpoints, bp, entry); QTAILQ_REMOVE(&current_cpu->kvm_state->kvm_sw_breakpoints, bp, entry);
g_free(bp); g_free(bp);
} else { } else {
err = kvm_arch_remove_hw_breakpoint(addr, len, type); err = kvm_arch_remove_hw_breakpoint(addr, len, type);
@ -1904,7 +1904,7 @@ void kvm_remove_all_breakpoints(CPUArchState *current_env)
{ {
CPUState *current_cpu = ENV_GET_CPU(current_env); CPUState *current_cpu = ENV_GET_CPU(current_env);
struct kvm_sw_breakpoint *bp, *next; struct kvm_sw_breakpoint *bp, *next;
KVMState *s = current_env->kvm_state; KVMState *s = current_cpu->kvm_state;
CPUArchState *env; CPUArchState *env;
CPUState *cpu; CPUState *cpu;

4
kvm.h
View File

@ -207,10 +207,10 @@ struct kvm_sw_breakpoint {
QTAILQ_HEAD(kvm_sw_breakpoint_head, kvm_sw_breakpoint); QTAILQ_HEAD(kvm_sw_breakpoint_head, kvm_sw_breakpoint);
struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUArchState *env, struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *cpu,
target_ulong pc); target_ulong pc);
int kvm_sw_breakpoints_active(CPUArchState *env); int kvm_sw_breakpoints_active(CPUState *cpu);
int kvm_arch_insert_sw_breakpoint(CPUState *current_cpu, int kvm_arch_insert_sw_breakpoint(CPUState *current_cpu,
struct kvm_sw_breakpoint *bp); struct kvm_sw_breakpoint *bp);

7
target-i386/cpu.c
View File

@ -1636,6 +1636,9 @@ void cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count,
uint32_t *eax, uint32_t *ebx, uint32_t *eax, uint32_t *ebx,
uint32_t *ecx, uint32_t *edx) uint32_t *ecx, uint32_t *edx)
{ {
X86CPU *cpu = x86_env_get_cpu(env);
CPUState *cs = CPU(cpu);
/* test if maximum index reached */ /* test if maximum index reached */
if (index & 0x80000000) { if (index & 0x80000000) {
if (index > env->cpuid_xlevel) { if (index > env->cpuid_xlevel) {
@ -1752,7 +1755,7 @@ void cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count,
case 0xA: case 0xA:
/* Architectural Performance Monitoring Leaf */ /* Architectural Performance Monitoring Leaf */
if (kvm_enabled()) { if (kvm_enabled()) {
KVMState *s = env->kvm_state; KVMState *s = cs->kvm_state;
*eax = kvm_arch_get_supported_cpuid(s, 0xA, count, R_EAX); *eax = kvm_arch_get_supported_cpuid(s, 0xA, count, R_EAX);
*ebx = kvm_arch_get_supported_cpuid(s, 0xA, count, R_EBX); *ebx = kvm_arch_get_supported_cpuid(s, 0xA, count, R_EBX);
@ -1775,7 +1778,7 @@ void cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count,
break; break;
} }
if (kvm_enabled()) { if (kvm_enabled()) {
KVMState *s = env->kvm_state; KVMState *s = cs->kvm_state;
*eax = kvm_arch_get_supported_cpuid(s, 0xd, count, R_EAX); *eax = kvm_arch_get_supported_cpuid(s, 0xd, count, R_EAX);
*ebx = kvm_arch_get_supported_cpuid(s, 0xd, count, R_EBX); *ebx = kvm_arch_get_supported_cpuid(s, 0xd, count, R_EBX);

22
target-i386/kvm.c
View File

@ -316,7 +316,7 @@ int kvm_arch_on_sigbus_vcpu(CPUState *c, int code, void *addr)
if ((env->mcg_cap & MCG_SER_P) && addr if ((env->mcg_cap & MCG_SER_P) && addr
&& (code == BUS_MCEERR_AR || code == BUS_MCEERR_AO)) { && (code == BUS_MCEERR_AR || code == BUS_MCEERR_AO)) {
if (qemu_ram_addr_from_host(addr, &ram_addr) || if (qemu_ram_addr_from_host(addr, &ram_addr) ||
!kvm_physical_memory_addr_from_host(env->kvm_state, addr, &paddr)) { !kvm_physical_memory_addr_from_host(c->kvm_state, addr, &paddr)) {
fprintf(stderr, "Hardware memory error for memory used by " fprintf(stderr, "Hardware memory error for memory used by "
"QEMU itself instead of guest system!\n"); "QEMU itself instead of guest system!\n");
/* Hope we are lucky for AO MCE */ /* Hope we are lucky for AO MCE */
@ -348,8 +348,8 @@ int kvm_arch_on_sigbus(int code, void *addr)
/* Hope we are lucky for AO MCE */ /* Hope we are lucky for AO MCE */
if (qemu_ram_addr_from_host(addr, &ram_addr) || if (qemu_ram_addr_from_host(addr, &ram_addr) ||
!kvm_physical_memory_addr_from_host(first_cpu->kvm_state, addr, !kvm_physical_memory_addr_from_host(CPU(first_cpu)->kvm_state,
&paddr)) { addr, &paddr)) {
fprintf(stderr, "Hardware memory error for memory used by " fprintf(stderr, "Hardware memory error for memory used by "
"QEMU itself instead of guest system!: %p\n", addr); "QEMU itself instead of guest system!: %p\n", addr);
return 0; return 0;
@ -579,12 +579,12 @@ int kvm_arch_init_vcpu(CPUState *cs)
if (((env->cpuid_version >> 8)&0xF) >= 6 if (((env->cpuid_version >> 8)&0xF) >= 6
&& (env->cpuid_features&(CPUID_MCE|CPUID_MCA)) == (CPUID_MCE|CPUID_MCA) && (env->cpuid_features&(CPUID_MCE|CPUID_MCA)) == (CPUID_MCE|CPUID_MCA)
&& kvm_check_extension(env->kvm_state, KVM_CAP_MCE) > 0) { && kvm_check_extension(cs->kvm_state, KVM_CAP_MCE) > 0) {
uint64_t mcg_cap; uint64_t mcg_cap;
int banks; int banks;
int ret; int ret;
ret = kvm_get_mce_cap_supported(env->kvm_state, &mcg_cap, &banks); ret = kvm_get_mce_cap_supported(cs->kvm_state, &mcg_cap, &banks);
if (ret < 0) { if (ret < 0) {
fprintf(stderr, "kvm_get_mce_cap_supported: %s", strerror(-ret)); fprintf(stderr, "kvm_get_mce_cap_supported: %s", strerror(-ret));
return ret; return ret;
@ -612,7 +612,7 @@ int kvm_arch_init_vcpu(CPUState *cs)
return r; return r;
} }
r = kvm_check_extension(env->kvm_state, KVM_CAP_TSC_CONTROL); r = kvm_check_extension(cs->kvm_state, KVM_CAP_TSC_CONTROL);
if (r && env->tsc_khz) { if (r && env->tsc_khz) {
r = kvm_vcpu_ioctl(cs, 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) {
@ -1977,9 +1977,10 @@ void kvm_arch_remove_all_hw_breakpoints(void)
static CPUWatchpoint hw_watchpoint; static CPUWatchpoint hw_watchpoint;
static int kvm_handle_debug(CPUX86State *env, static int kvm_handle_debug(X86CPU *cpu,
struct kvm_debug_exit_arch *arch_info) struct kvm_debug_exit_arch *arch_info)
{ {
CPUX86State *env = &cpu->env;
int ret = 0; int ret = 0;
int n; int n;
@ -2011,7 +2012,7 @@ static int kvm_handle_debug(CPUX86State *env,
} }
} }
} }
} else if (kvm_find_sw_breakpoint(env, arch_info->pc)) { } else if (kvm_find_sw_breakpoint(CPU(cpu), arch_info->pc)) {
ret = EXCP_DEBUG; ret = EXCP_DEBUG;
} }
if (ret == 0) { if (ret == 0) {
@ -2028,7 +2029,6 @@ static int kvm_handle_debug(CPUX86State *env,
void kvm_arch_update_guest_debug(CPUState *cpu, struct kvm_guest_debug *dbg) void kvm_arch_update_guest_debug(CPUState *cpu, struct kvm_guest_debug *dbg)
{ {
CPUX86State *env = &X86_CPU(cpu)->env;
const uint8_t type_code[] = { const uint8_t type_code[] = {
[GDB_BREAKPOINT_HW] = 0x0, [GDB_BREAKPOINT_HW] = 0x0,
[GDB_WATCHPOINT_WRITE] = 0x1, [GDB_WATCHPOINT_WRITE] = 0x1,
@ -2039,7 +2039,7 @@ void kvm_arch_update_guest_debug(CPUState *cpu, struct kvm_guest_debug *dbg)
}; };
int n; int n;
if (kvm_sw_breakpoints_active(env)) { if (kvm_sw_breakpoints_active(cpu)) {
dbg->control |= KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_USE_SW_BP; dbg->control |= KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_USE_SW_BP;
} }
if (nb_hw_breakpoint > 0) { if (nb_hw_breakpoint > 0) {
@ -2106,7 +2106,7 @@ int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run)
break; break;
case KVM_EXIT_DEBUG: case KVM_EXIT_DEBUG:
DPRINTF("kvm_exit_debug\n"); DPRINTF("kvm_exit_debug\n");
ret = kvm_handle_debug(env, &run->debug.arch); ret = kvm_handle_debug(cpu, &run->debug.arch);
break; break;
default: default:
fprintf(stderr, "KVM: unknown exit reason %d\n", run->exit_reason); fprintf(stderr, "KVM: unknown exit reason %d\n", run->exit_reason);

33
target-ppc/kvm.c
View File

@ -140,7 +140,7 @@ static int kvm_booke206_tlb_init(PowerPCCPU *cpu)
int ret, i; int ret, i;
if (!kvm_enabled() || if (!kvm_enabled() ||
!kvm_check_extension(env->kvm_state, KVM_CAP_SW_TLB)) { !kvm_check_extension(cs->kvm_state, KVM_CAP_SW_TLB)) {
return 0; return 0;
} }
@ -178,9 +178,12 @@ static int kvm_booke206_tlb_init(PowerPCCPU *cpu)
#if defined(TARGET_PPC64) #if defined(TARGET_PPC64)
static void kvm_get_fallback_smmu_info(CPUPPCState *env, static void kvm_get_fallback_smmu_info(PowerPCCPU *cpu,
struct kvm_ppc_smmu_info *info) struct kvm_ppc_smmu_info *info)
{ {
CPUPPCState *env = &cpu->env;
CPUState *cs = CPU(cpu);
memset(info, 0, sizeof(*info)); memset(info, 0, sizeof(*info));
/* We don't have the new KVM_PPC_GET_SMMU_INFO ioctl, so /* We don't have the new KVM_PPC_GET_SMMU_INFO ioctl, so
@ -206,7 +209,7 @@ static void kvm_get_fallback_smmu_info(CPUPPCState *env,
* implements KVM_CAP_PPC_GET_SMMU_INFO and thus doesn't hit * implements KVM_CAP_PPC_GET_SMMU_INFO and thus doesn't hit
* this fallback. * this fallback.
*/ */
if (kvm_check_extension(env->kvm_state, KVM_CAP_PPC_GET_PVINFO)) { if (kvm_check_extension(cs->kvm_state, KVM_CAP_PPC_GET_PVINFO)) {
/* No flags */ /* No flags */
info->flags = 0; info->flags = 0;
info->slb_size = 64; info->slb_size = 64;
@ -262,18 +265,19 @@ static void kvm_get_fallback_smmu_info(CPUPPCState *env,
} }
} }
static void kvm_get_smmu_info(CPUPPCState *env, struct kvm_ppc_smmu_info *info) static void kvm_get_smmu_info(PowerPCCPU *cpu, struct kvm_ppc_smmu_info *info)
{ {
CPUState *cs = CPU(cpu);
int ret; int ret;
if (kvm_check_extension(env->kvm_state, KVM_CAP_PPC_GET_SMMU_INFO)) { if (kvm_check_extension(cs->kvm_state, KVM_CAP_PPC_GET_SMMU_INFO)) {
ret = kvm_vm_ioctl(env->kvm_state, KVM_PPC_GET_SMMU_INFO, info); ret = kvm_vm_ioctl(cs->kvm_state, KVM_PPC_GET_SMMU_INFO, info);
if (ret == 0) { if (ret == 0) {
return; return;
} }
} }
kvm_get_fallback_smmu_info(env, info); kvm_get_fallback_smmu_info(cpu, info);
} }
static long getrampagesize(void) static long getrampagesize(void)
@ -316,10 +320,11 @@ static bool kvm_valid_page_size(uint32_t flags, long rampgsize, uint32_t shift)
return (1ul << shift) <= rampgsize; return (1ul << shift) <= rampgsize;
} }
static void kvm_fixup_page_sizes(CPUPPCState *env) static void kvm_fixup_page_sizes(PowerPCCPU *cpu)
{ {
static struct kvm_ppc_smmu_info smmu_info; static struct kvm_ppc_smmu_info smmu_info;
static bool has_smmu_info; static bool has_smmu_info;
CPUPPCState *env = &cpu->env;
long rampagesize; long rampagesize;
int iq, ik, jq, jk; int iq, ik, jq, jk;
@ -330,7 +335,7 @@ static void kvm_fixup_page_sizes(CPUPPCState *env)
/* Collect MMU info from kernel if not already */ /* Collect MMU info from kernel if not already */
if (!has_smmu_info) { if (!has_smmu_info) {
kvm_get_smmu_info(env, &smmu_info); kvm_get_smmu_info(cpu, &smmu_info);
has_smmu_info = true; has_smmu_info = true;
} }
@ -373,7 +378,7 @@ static void kvm_fixup_page_sizes(CPUPPCState *env)
} }
#else /* defined (TARGET_PPC64) */ #else /* defined (TARGET_PPC64) */
static inline void kvm_fixup_page_sizes(CPUPPCState *env) static inline void kvm_fixup_page_sizes(PowerPCCPU *cpu)
{ {
} }
@ -386,7 +391,7 @@ int kvm_arch_init_vcpu(CPUState *cs)
int ret; int ret;
/* Gather server mmu info from KVM and update the CPU state */ /* Gather server mmu info from KVM and update the CPU state */
kvm_fixup_page_sizes(cenv); kvm_fixup_page_sizes(cpu);
/* Synchronize sregs with kvm */ /* Synchronize sregs with kvm */
ret = kvm_arch_sync_sregs(cpu); ret = kvm_arch_sync_sregs(cpu);
@ -986,12 +991,14 @@ 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)
{ {
PowerPCCPU *cpu = ppc_env_get_cpu(env);
CPUState *cs = CPU(cpu);
uint32_t *hc = (uint32_t*)buf; uint32_t *hc = (uint32_t*)buf;
struct kvm_ppc_pvinfo pvinfo; struct kvm_ppc_pvinfo pvinfo;
if (kvm_check_extension(env->kvm_state, KVM_CAP_PPC_GET_PVINFO) && if (kvm_check_extension(cs->kvm_state, KVM_CAP_PPC_GET_PVINFO) &&
!kvm_vm_ioctl(env->kvm_state, KVM_PPC_GET_PVINFO, &pvinfo)) { !kvm_vm_ioctl(cs->kvm_state, KVM_PPC_GET_PVINFO, &pvinfo)) {
memcpy(buf, pvinfo.hcall, buf_len); memcpy(buf, pvinfo.hcall, buf_len);
return 0; return 0;

5
target-s390x/kvm.c
View File

@ -291,12 +291,11 @@ int kvm_arch_process_async_events(CPUState *cs)
void kvm_s390_interrupt_internal(S390CPU *cpu, 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); CPUState *cs = CPU(cpu);
struct kvm_s390_interrupt kvmint; struct kvm_s390_interrupt kvmint;
int r; int r;
if (!env->kvm_state) { if (!cs->kvm_state) {
return; return;
} }
@ -305,7 +304,7 @@ void kvm_s390_interrupt_internal(S390CPU *cpu, int type, uint32_t parm,
kvmint.parm64 = parm64; kvmint.parm64 = parm64;
if (vm) { if (vm) {
r = kvm_vm_ioctl(env->kvm_state, KVM_S390_INTERRUPT, &kvmint); r = kvm_vm_ioctl(cs->kvm_state, KVM_S390_INTERRUPT, &kvmint);
} else { } else {
r = kvm_vcpu_ioctl(cs, KVM_S390_INTERRUPT, &kvmint); r = kvm_vcpu_ioctl(cs, KVM_S390_INTERRUPT, &kvmint);
} }