From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([208.118.235.92]:46800) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1Tk1rl-0000jk-Rf for qemu-devel@nongnu.org; Sat, 15 Dec 2012 19:14:04 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1Tk1ri-0004sa-FW for qemu-devel@nongnu.org; Sat, 15 Dec 2012 19:14:01 -0500 From: =?UTF-8?q?Andreas=20F=C3=A4rber?= Date: Sun, 16 Dec 2012 01:13:28 +0100 Message-Id: <1355616817-1260-3-git-send-email-afaerber@suse.de> In-Reply-To: <1355616817-1260-1-git-send-email-afaerber@suse.de> References: <1355616817-1260-1-git-send-email-afaerber@suse.de> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable Subject: [Qemu-devel] [PATCH v2 02/11] kvm: Pass CPUState to kvm_arch_* List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org Cc: kvm@vger.kernel.org, Marcelo Tosatti , Alexander Graf , "open list:PowerPC" , Avi Kivity , =?UTF-8?q?Andreas=20F=C3=A4rber?= Move kvm_vcpu_dirty field into CPUState to simplify things and change its type to bool while at it. Signed-off-by: Andreas F=C3=A4rber --- cpu-defs.h | 3 +-- include/qemu/cpu.h | 1 + kvm-all.c | 75 ++++++++++++++++++++++++++++++----------------= ------ kvm.h | 26 +++++++++--------- target-i386/kvm.c | 59 +++++++++++++++++++++++++++-------------- target-ppc/kvm.c | 36 ++++++++++++++++--------- target-s390x/kvm.c | 38 +++++++++++++++++--------- 7 Dateien ge=C3=A4ndert, 146 Zeilen hinzugef=C3=BCgt(+), 92 Zeilen entfe= rnt(-) diff --git a/cpu-defs.h b/cpu-defs.h index 6373a80..a382e35 100644 --- a/cpu-defs.h +++ b/cpu-defs.h @@ -206,7 +206,6 @@ typedef struct CPUWatchpoint { = \ const char *cpu_model_str; = \ struct KVMState *kvm_state; = \ - struct kvm_run *kvm_run; = \ - int kvm_vcpu_dirty; + struct kvm_run *kvm_run; =20 #endif diff --git a/include/qemu/cpu.h b/include/qemu/cpu.h index 6049a20..b8f8dd1 100644 --- a/include/qemu/cpu.h +++ b/include/qemu/cpu.h @@ -80,6 +80,7 @@ struct CPUState { =20 #if !defined(CONFIG_USER_ONLY) int kvm_fd; + bool kvm_vcpu_dirty; #endif =20 /* TODO Move common fields from CPUArchState here. */ diff --git a/kvm-all.c b/kvm-all.c index 8a00df7..792cdf1 100644 --- a/kvm-all.c +++ b/kvm-all.c @@ -209,9 +209,9 @@ static int kvm_set_user_memory_region(KVMState *s, KV= MSlot *slot) =20 static void kvm_reset_vcpu(void *opaque) { - CPUArchState *env =3D opaque; + CPUState *cpu =3D opaque; =20 - kvm_arch_reset_vcpu(env); + kvm_arch_reset_vcpu(cpu); } =20 int kvm_init_vcpu(CPUArchState *env) @@ -231,7 +231,7 @@ int kvm_init_vcpu(CPUArchState *env) =20 cpu->kvm_fd =3D ret; env->kvm_state =3D s; - env->kvm_vcpu_dirty =3D 1; + cpu->kvm_vcpu_dirty =3D true; =20 mmap_size =3D kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, 0); if (mmap_size < 0) { @@ -253,10 +253,10 @@ int kvm_init_vcpu(CPUArchState *env) (void *)env->kvm_run + s->coalesced_mmio * PAGE_SIZE; } =20 - ret =3D kvm_arch_init_vcpu(env); + ret =3D kvm_arch_init_vcpu(cpu); if (ret =3D=3D 0) { - qemu_register_reset(kvm_reset_vcpu, env); - kvm_arch_reset_vcpu(env); + qemu_register_reset(kvm_reset_vcpu, cpu); + kvm_arch_reset_vcpu(cpu); } err: return ret; @@ -1438,6 +1438,8 @@ static void kvm_handle_io(uint16_t port, void *data= , int direction, int size, =20 static int kvm_handle_internal_error(CPUArchState *env, struct kvm_run *= run) { + CPUState *cpu =3D ENV_GET_CPU(env); + fprintf(stderr, "KVM internal error."); if (kvm_check_extension(kvm_state, KVM_CAP_INTERNAL_ERROR_DATA)) { int i; @@ -1452,7 +1454,7 @@ static int kvm_handle_internal_error(CPUArchState *= env, struct kvm_run *run) } if (run->internal.suberror =3D=3D KVM_INTERNAL_ERROR_EMULATION) { fprintf(stderr, "emulation failure\n"); - if (!kvm_arch_stop_on_emulation_error(env)) { + if (!kvm_arch_stop_on_emulation_error(cpu)) { cpu_dump_state(env, stderr, fprintf, CPU_DUMP_CODE); return EXCP_INTERRUPT; } @@ -1489,13 +1491,13 @@ void kvm_flush_coalesced_mmio_buffer(void) s->coalesced_flush_in_progress =3D false; } =20 -static void do_kvm_cpu_synchronize_state(void *_env) +static void do_kvm_cpu_synchronize_state(void *arg) { - CPUArchState *env =3D _env; + CPUState *cpu =3D arg; =20 - if (!env->kvm_vcpu_dirty) { - kvm_arch_get_registers(env); - env->kvm_vcpu_dirty =3D 1; + if (!cpu->kvm_vcpu_dirty) { + kvm_arch_get_registers(cpu); + cpu->kvm_vcpu_dirty =3D true; } } =20 @@ -1503,42 +1505,47 @@ void kvm_cpu_synchronize_state(CPUArchState *env) { CPUState *cpu =3D ENV_GET_CPU(env); =20 - if (!env->kvm_vcpu_dirty) { - run_on_cpu(cpu, do_kvm_cpu_synchronize_state, env); + if (!cpu->kvm_vcpu_dirty) { + run_on_cpu(cpu, do_kvm_cpu_synchronize_state, cpu); } } =20 void kvm_cpu_synchronize_post_reset(CPUArchState *env) { - kvm_arch_put_registers(env, KVM_PUT_RESET_STATE); - env->kvm_vcpu_dirty =3D 0; + CPUState *cpu =3D ENV_GET_CPU(env); + + kvm_arch_put_registers(cpu, KVM_PUT_RESET_STATE); + cpu->kvm_vcpu_dirty =3D false; } =20 void kvm_cpu_synchronize_post_init(CPUArchState *env) { - kvm_arch_put_registers(env, KVM_PUT_FULL_STATE); - env->kvm_vcpu_dirty =3D 0; + CPUState *cpu =3D ENV_GET_CPU(env); + + kvm_arch_put_registers(cpu, KVM_PUT_FULL_STATE); + cpu->kvm_vcpu_dirty =3D false; } =20 int kvm_cpu_exec(CPUArchState *env) { + CPUState *cpu =3D ENV_GET_CPU(env); struct kvm_run *run =3D env->kvm_run; int ret, run_ret; =20 DPRINTF("kvm_cpu_exec()\n"); =20 - if (kvm_arch_process_async_events(env)) { + if (kvm_arch_process_async_events(cpu)) { env->exit_request =3D 0; return EXCP_HLT; } =20 do { - if (env->kvm_vcpu_dirty) { - kvm_arch_put_registers(env, KVM_PUT_RUNTIME_STATE); - env->kvm_vcpu_dirty =3D 0; + if (cpu->kvm_vcpu_dirty) { + kvm_arch_put_registers(cpu, KVM_PUT_RUNTIME_STATE); + cpu->kvm_vcpu_dirty =3D false; } =20 - kvm_arch_pre_run(env, run); + kvm_arch_pre_run(cpu, run); if (env->exit_request) { DPRINTF("interrupt exit requested\n"); /* @@ -1553,7 +1560,7 @@ int kvm_cpu_exec(CPUArchState *env) run_ret =3D kvm_vcpu_ioctl(env, KVM_RUN, 0); =20 qemu_mutex_lock_iothread(); - kvm_arch_post_run(env, run); + kvm_arch_post_run(cpu, run); =20 if (run_ret < 0) { if (run_ret =3D=3D -EINTR || run_ret =3D=3D -EAGAIN) { @@ -1603,7 +1610,7 @@ int kvm_cpu_exec(CPUArchState *env) break; default: DPRINTF("kvm_arch_handle_exit\n"); - ret =3D kvm_arch_handle_exit(env, run); + ret =3D kvm_arch_handle_exit(cpu, run); break; } } while (ret =3D=3D 0); @@ -1799,7 +1806,7 @@ int kvm_update_guest_debug(CPUArchState *env, unsig= ned long reinject_trap) if (env->singlestep_enabled) { data.dbg.control |=3D KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_SINGLES= TEP; } - kvm_arch_update_guest_debug(env, &data.dbg); + kvm_arch_update_guest_debug(cpu, &data.dbg); data.env =3D env; =20 run_on_cpu(cpu, kvm_invoke_set_guest_debug, &data); @@ -1809,6 +1816,7 @@ int kvm_update_guest_debug(CPUArchState *env, unsig= ned long reinject_trap) int kvm_insert_breakpoint(CPUArchState *current_env, target_ulong addr, target_ulong len, int type) { + CPUState *current_cpu =3D ENV_GET_CPU(current_env); struct kvm_sw_breakpoint *bp; CPUArchState *env; int err; @@ -1827,7 +1835,7 @@ int kvm_insert_breakpoint(CPUArchState *current_env= , target_ulong addr, =20 bp->pc =3D addr; bp->use_count =3D 1; - err =3D kvm_arch_insert_sw_breakpoint(current_env, bp); + err =3D kvm_arch_insert_sw_breakpoint(current_cpu, bp); if (err) { g_free(bp); return err; @@ -1854,6 +1862,7 @@ int kvm_insert_breakpoint(CPUArchState *current_env= , target_ulong addr, int kvm_remove_breakpoint(CPUArchState *current_env, target_ulong addr, target_ulong len, int type) { + CPUState *current_cpu =3D ENV_GET_CPU(current_env); struct kvm_sw_breakpoint *bp; CPUArchState *env; int err; @@ -1869,7 +1878,7 @@ int kvm_remove_breakpoint(CPUArchState *current_env= , target_ulong addr, return 0; } =20 - err =3D kvm_arch_remove_sw_breakpoint(current_env, bp); + err =3D kvm_arch_remove_sw_breakpoint(current_cpu, bp); if (err) { return err; } @@ -1894,15 +1903,18 @@ int kvm_remove_breakpoint(CPUArchState *current_e= nv, target_ulong addr, =20 void kvm_remove_all_breakpoints(CPUArchState *current_env) { + CPUState *current_cpu =3D ENV_GET_CPU(current_env); struct kvm_sw_breakpoint *bp, *next; KVMState *s =3D current_env->kvm_state; CPUArchState *env; + CPUState *cpu; =20 QTAILQ_FOREACH_SAFE(bp, &s->kvm_sw_breakpoints, entry, next) { - if (kvm_arch_remove_sw_breakpoint(current_env, bp) !=3D 0) { + if (kvm_arch_remove_sw_breakpoint(current_cpu, bp) !=3D 0) { /* Try harder to find a CPU that currently sees the breakpoi= nt. */ for (env =3D first_cpu; env !=3D NULL; env =3D env->next_cpu= ) { - if (kvm_arch_remove_sw_breakpoint(env, bp) =3D=3D 0) { + cpu =3D ENV_GET_CPU(env); + if (kvm_arch_remove_sw_breakpoint(cpu, bp) =3D=3D 0) { break; } } @@ -2014,7 +2026,8 @@ int kvm_set_ioeventfd_pio_word(int fd, uint16_t add= r, uint16_t val, bool assign) =20 int kvm_on_sigbus_vcpu(CPUArchState *env, int code, void *addr) { - return kvm_arch_on_sigbus_vcpu(env, code, addr); + CPUState *cpu =3D ENV_GET_CPU(env); + return kvm_arch_on_sigbus_vcpu(cpu, code, addr); } =20 int kvm_on_sigbus(int code, void *addr) diff --git a/kvm.h b/kvm.h index 72d866a..61f00b7 100644 --- a/kvm.h +++ b/kvm.h @@ -158,14 +158,14 @@ int kvm_vcpu_ioctl(CPUArchState *env, int type, ...= ); =20 extern const KVMCapabilityInfo kvm_arch_required_capabilities[]; =20 -void kvm_arch_pre_run(CPUArchState *env, struct kvm_run *run); -void kvm_arch_post_run(CPUArchState *env, struct kvm_run *run); +void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run); +void kvm_arch_post_run(CPUState *cpu, struct kvm_run *run); =20 -int kvm_arch_handle_exit(CPUArchState *env, struct kvm_run *run); +int kvm_arch_handle_exit(CPUState *cpu, struct kvm_run *run); =20 -int kvm_arch_process_async_events(CPUArchState *env); +int kvm_arch_process_async_events(CPUState *cpu); =20 -int kvm_arch_get_registers(CPUArchState *env); +int kvm_arch_get_registers(CPUState *cpu); =20 /* state subset only touched by the VCPU itself during runtime */ #define KVM_PUT_RUNTIME_STATE 1 @@ -174,15 +174,15 @@ int kvm_arch_get_registers(CPUArchState *env); /* full state set, modified during initialization or on vmload */ #define KVM_PUT_FULL_STATE 3 =20 -int kvm_arch_put_registers(CPUArchState *env, int level); +int kvm_arch_put_registers(CPUState *cpu, int level); =20 int kvm_arch_init(KVMState *s); =20 -int kvm_arch_init_vcpu(CPUArchState *env); +int kvm_arch_init_vcpu(CPUState *cpu); =20 -void kvm_arch_reset_vcpu(CPUArchState *env); +void kvm_arch_reset_vcpu(CPUState *cpu); =20 -int kvm_arch_on_sigbus_vcpu(CPUArchState *env, int code, void *addr); +int kvm_arch_on_sigbus_vcpu(CPUState *cpu, int code, void *addr); int kvm_arch_on_sigbus(int code, void *addr); =20 void kvm_arch_init_irq_routing(KVMState *s); @@ -212,9 +212,9 @@ struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUA= rchState *env, =20 int kvm_sw_breakpoints_active(CPUArchState *env); =20 -int kvm_arch_insert_sw_breakpoint(CPUArchState *current_env, +int kvm_arch_insert_sw_breakpoint(CPUState *current_cpu, struct kvm_sw_breakpoint *bp); -int kvm_arch_remove_sw_breakpoint(CPUArchState *current_env, +int kvm_arch_remove_sw_breakpoint(CPUState *current_cpu, struct kvm_sw_breakpoint *bp); int kvm_arch_insert_hw_breakpoint(target_ulong addr, target_ulong len, int type); @@ -222,9 +222,9 @@ int kvm_arch_remove_hw_breakpoint(target_ulong addr, target_ulong len, int type); void kvm_arch_remove_all_hw_breakpoints(void); =20 -void kvm_arch_update_guest_debug(CPUArchState *env, struct kvm_guest_deb= ug *dbg); +void kvm_arch_update_guest_debug(CPUState *cpu, struct kvm_guest_debug *= dbg); =20 -bool kvm_arch_stop_on_emulation_error(CPUArchState *env); +bool kvm_arch_stop_on_emulation_error(CPUState *cpu); =20 int kvm_check_extension(KVMState *s, unsigned int extension); =20 diff --git a/target-i386/kvm.c b/target-i386/kvm.c index f669281..80cacf3 100644 --- a/target-i386/kvm.c +++ b/target-i386/kvm.c @@ -306,9 +306,10 @@ static void hardware_memory_error(void) exit(1); } =20 -int kvm_arch_on_sigbus_vcpu(CPUX86State *env, int code, void *addr) +int kvm_arch_on_sigbus_vcpu(CPUState *c, int code, void *addr) { - X86CPU *cpu =3D x86_env_get_cpu(env); + X86CPU *cpu =3D X86_CPU(c); + CPUX86State *env =3D &cpu->env; ram_addr_t ram_addr; hwaddr paddr; =20 @@ -406,12 +407,14 @@ static void cpu_update_state(void *opaque, int runn= ing, RunState state) } } =20 -int kvm_arch_init_vcpu(CPUX86State *env) +int kvm_arch_init_vcpu(CPUState *cs) { struct { struct kvm_cpuid2 cpuid; struct kvm_cpuid_entry2 entries[100]; } QEMU_PACKED cpuid_data; + X86CPU *cpu =3D X86_CPU(cs); + CPUX86State *env =3D &cpu->env; uint32_t limit, i, j, cpuid_i; uint32_t unused; struct kvm_cpuid_entry2 *c; @@ -623,9 +626,10 @@ int kvm_arch_init_vcpu(CPUX86State *env) return 0; } =20 -void kvm_arch_reset_vcpu(CPUX86State *env) +void kvm_arch_reset_vcpu(CPUState *cs) { - X86CPU *cpu =3D x86_env_get_cpu(env); + X86CPU *cpu =3D X86_CPU(cs); + CPUX86State *env =3D &cpu->env; =20 env->exception_injected =3D -1; env->interrupt_injected =3D -1; @@ -1582,9 +1586,10 @@ static int kvm_get_debugregs(CPUX86State *env) return 0; } =20 -int kvm_arch_put_registers(CPUX86State *env, int level) +int kvm_arch_put_registers(CPUState *cpu, int level) { - CPUState *cpu =3D ENV_GET_CPU(env); + X86CPU *x86_cpu =3D X86_CPU(cpu); + CPUX86State *env =3D &x86_cpu->env; int ret; =20 assert(cpu_is_stopped(cpu) || qemu_cpu_is_self(cpu)); @@ -1640,12 +1645,13 @@ int kvm_arch_put_registers(CPUX86State *env, int = level) return 0; } =20 -int kvm_arch_get_registers(CPUX86State *env) +int kvm_arch_get_registers(CPUState *cs) { - X86CPU *cpu =3D x86_env_get_cpu(env); + X86CPU *cpu =3D X86_CPU(cs); + CPUX86State *env =3D &cpu->env; int ret; =20 - assert(cpu_is_stopped(CPU(cpu)) || qemu_cpu_is_self(CPU(cpu))); + assert(cpu_is_stopped(cs) || qemu_cpu_is_self(cs)); =20 ret =3D kvm_getput_regs(env, 0); if (ret < 0) { @@ -1686,8 +1692,10 @@ int kvm_arch_get_registers(CPUX86State *env) return 0; } =20 -void kvm_arch_pre_run(CPUX86State *env, struct kvm_run *run) +void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run) { + X86CPU *x86_cpu =3D X86_CPU(cpu); + CPUX86State *env =3D &x86_cpu->env; int ret; =20 /* Inject NMI */ @@ -1746,8 +1754,11 @@ void kvm_arch_pre_run(CPUX86State *env, struct kvm= _run *run) } } =20 -void kvm_arch_post_run(CPUX86State *env, struct kvm_run *run) +void kvm_arch_post_run(CPUState *cpu, struct kvm_run *run) { + X86CPU *x86_cpu =3D X86_CPU(cpu); + CPUX86State *env =3D &x86_cpu->env; + if (run->if_flag) { env->eflags |=3D IF_MASK; } else { @@ -1757,9 +1768,10 @@ void kvm_arch_post_run(CPUX86State *env, struct kv= m_run *run) cpu_set_apic_base(env->apic_state, run->apic_base); } =20 -int kvm_arch_process_async_events(CPUX86State *env) +int kvm_arch_process_async_events(CPUState *cs) { - X86CPU *cpu =3D x86_env_get_cpu(env); + X86CPU *cpu =3D X86_CPU(cs); + CPUX86State *env =3D &cpu->env; =20 if (env->interrupt_request & CPU_INTERRUPT_MCE) { /* We must not raise CPU_INTERRUPT_MCE if it's not supported. */ @@ -1839,8 +1851,9 @@ static int kvm_handle_tpr_access(CPUX86State *env) return 1; } =20 -int kvm_arch_insert_sw_breakpoint(CPUX86State *env, struct kvm_sw_breakp= oint *bp) +int kvm_arch_insert_sw_breakpoint(CPUState *cpu, struct kvm_sw_breakpoin= t *bp) { + CPUX86State *env =3D &X86_CPU(cpu)->env; static const uint8_t int3 =3D 0xcc; =20 if (cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&bp->saved_insn, 1, = 0) || @@ -1850,8 +1863,9 @@ int kvm_arch_insert_sw_breakpoint(CPUX86State *env,= struct kvm_sw_breakpoint *bp return 0; } =20 -int kvm_arch_remove_sw_breakpoint(CPUX86State *env, struct kvm_sw_breakp= oint *bp) +int kvm_arch_remove_sw_breakpoint(CPUState *cpu, struct kvm_sw_breakpoin= t *bp) { + CPUX86State *env =3D &X86_CPU(cpu)->env; uint8_t int3; =20 if (cpu_memory_rw_debug(env, bp->pc, &int3, 1, 0) || int3 !=3D 0xcc = || @@ -1994,8 +2008,9 @@ static int kvm_handle_debug(CPUX86State *env, return ret; } =20 -void kvm_arch_update_guest_debug(CPUX86State *env, struct kvm_guest_debu= g *dbg) +void kvm_arch_update_guest_debug(CPUState *cpu, struct kvm_guest_debug *= dbg) { + CPUX86State *env =3D &X86_CPU(cpu)->env; const uint8_t type_code[] =3D { [GDB_BREAKPOINT_HW] =3D 0x0, [GDB_WATCHPOINT_WRITE] =3D 0x1, @@ -2031,9 +2046,10 @@ static bool host_supports_vmx(void) =20 #define VMX_INVALID_GUEST_STATE 0x80000021 =20 -int kvm_arch_handle_exit(CPUX86State *env, struct kvm_run *run) +int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run) { - X86CPU *cpu =3D x86_env_get_cpu(env); + X86CPU *cpu =3D X86_CPU(cs); + CPUX86State *env =3D &cpu->env; uint64_t code; int ret; =20 @@ -2083,8 +2099,11 @@ int kvm_arch_handle_exit(CPUX86State *env, struct = kvm_run *run) return ret; } =20 -bool kvm_arch_stop_on_emulation_error(CPUX86State *env) +bool kvm_arch_stop_on_emulation_error(CPUState *cs) { + X86CPU *cpu =3D X86_CPU(cs); + CPUX86State *env =3D &cpu->env; + kvm_cpu_synchronize_state(env); return !(env->cr[0] & CR0_PE_MASK) || ((env->segs[R_CS].selector & 3) !=3D 3); diff --git a/target-ppc/kvm.c b/target-ppc/kvm.c index 3f5df57..8a59b70 100644 --- a/target-ppc/kvm.c +++ b/target-ppc/kvm.c @@ -375,9 +375,10 @@ static inline void kvm_fixup_page_sizes(CPUPPCState = *env) =20 #endif /* !defined (TARGET_PPC64) */ =20 -int kvm_arch_init_vcpu(CPUPPCState *cenv) +int kvm_arch_init_vcpu(CPUState *cs) { - PowerPCCPU *cpu =3D ppc_env_get_cpu(cenv); + PowerPCCPU *cpu =3D POWERPC_CPU(cs); + CPUPPCState *cenv =3D &cpu->env; int ret; =20 /* Gather server mmu info from KVM and update the CPU state */ @@ -403,7 +404,7 @@ int kvm_arch_init_vcpu(CPUPPCState *cenv) return ret; } =20 -void kvm_arch_reset_vcpu(CPUPPCState *env) +void kvm_arch_reset_vcpu(CPUState *cpu) { } =20 @@ -432,8 +433,10 @@ static void kvm_sw_tlb_put(CPUPPCState *env) g_free(bitmap); } =20 -int kvm_arch_put_registers(CPUPPCState *env, int level) +int kvm_arch_put_registers(CPUState *cs, int level) { + PowerPCCPU *cpu =3D POWERPC_CPU(cs); + CPUPPCState *env =3D &cpu->env; struct kvm_regs regs; int ret; int i; @@ -525,8 +528,10 @@ int kvm_arch_put_registers(CPUPPCState *env, int lev= el) return ret; } =20 -int kvm_arch_get_registers(CPUPPCState *env) +int kvm_arch_get_registers(CPUState *cs) { + PowerPCCPU *cpu =3D POWERPC_CPU(cs); + CPUPPCState *env =3D &cpu->env; struct kvm_regs regs; struct kvm_sregs sregs; uint32_t cr; @@ -727,8 +732,10 @@ int kvmppc_set_interrupt(CPUPPCState *env, int irq, = int level) #define PPC_INPUT_INT PPC6xx_INPUT_INT #endif =20 -void kvm_arch_pre_run(CPUPPCState *env, struct kvm_run *run) +void kvm_arch_pre_run(CPUState *cs, struct kvm_run *run) { + PowerPCCPU *cpu =3D POWERPC_CPU(cs); + CPUPPCState *env =3D &cpu->env; int r; unsigned irq; =20 @@ -760,13 +767,14 @@ void kvm_arch_pre_run(CPUPPCState *env, struct kvm_= run *run) * anyways, so we will get a chance to deliver the rest. */ } =20 -void kvm_arch_post_run(CPUPPCState *env, struct kvm_run *run) +void kvm_arch_post_run(CPUState *cpu, struct kvm_run *run) { } =20 -int kvm_arch_process_async_events(CPUPPCState *env) +int kvm_arch_process_async_events(CPUState *cs) { - return env->halted; + PowerPCCPU *cpu =3D POWERPC_CPU(cs); + return cpu->env.halted; } =20 static int kvmppc_handle_halt(CPUPPCState *env) @@ -796,8 +804,10 @@ static int kvmppc_handle_dcr_write(CPUPPCState *env,= uint32_t dcrn, uint32_t dat return 0; } =20 -int kvm_arch_handle_exit(CPUPPCState *env, struct kvm_run *run) +int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run) { + PowerPCCPU *cpu =3D POWERPC_CPU(cs); + CPUPPCState *env =3D &cpu->env; int ret; =20 switch (run->exit_reason) { @@ -817,7 +827,7 @@ int kvm_arch_handle_exit(CPUPPCState *env, struct kvm= _run *run) #ifdef CONFIG_PSERIES case KVM_EXIT_PAPR_HCALL: dprintf("handle PAPR hypercall\n"); - run->papr_hcall.ret =3D spapr_hypercall(ppc_env_get_cpu(env), + run->papr_hcall.ret =3D spapr_hypercall(cpu, run->papr_hcall.nr, run->papr_hcall.args); ret =3D 0; @@ -1225,12 +1235,12 @@ int kvmppc_fixup_cpu(CPUPPCState *env) } =20 =20 -bool kvm_arch_stop_on_emulation_error(CPUPPCState *env) +bool kvm_arch_stop_on_emulation_error(CPUState *cpu) { return true; } =20 -int kvm_arch_on_sigbus_vcpu(CPUPPCState *env, int code, void *addr) +int kvm_arch_on_sigbus_vcpu(CPUState *cpu, int code, void *addr) { return 1; } diff --git a/target-s390x/kvm.c b/target-s390x/kvm.c index 94de764..d4e6ab2 100644 --- a/target-s390x/kvm.c +++ b/target-s390x/kvm.c @@ -72,8 +72,9 @@ int kvm_arch_init(KVMState *s) return 0; } =20 -int kvm_arch_init_vcpu(CPUS390XState *env) +int kvm_arch_init_vcpu(CPUState *cpu) { + CPUS390XState *env =3D &S390_CPU(cpu)->env; int ret =3D 0; =20 if (kvm_vcpu_ioctl(env, KVM_S390_INITIAL_RESET, NULL) < 0) { @@ -83,13 +84,15 @@ int kvm_arch_init_vcpu(CPUS390XState *env) return ret; } =20 -void kvm_arch_reset_vcpu(CPUS390XState *env) +void kvm_arch_reset_vcpu(CPUState *cpu) { /* FIXME: add code to reset vcpu. */ } =20 -int kvm_arch_put_registers(CPUS390XState *env, int level) +int kvm_arch_put_registers(CPUState *cs, int level) { + S390CPU *cpu =3D S390_CPU(cs); + CPUS390XState *env =3D &cpu->env; struct kvm_sregs sregs; struct kvm_regs regs; int ret; @@ -149,8 +152,10 @@ int kvm_arch_put_registers(CPUS390XState *env, int l= evel) return 0; } =20 -int kvm_arch_get_registers(CPUS390XState *env) +int kvm_arch_get_registers(CPUState *cs) { + S390CPU *cpu =3D S390_CPU(cs); + CPUS390XState *env =3D &cpu->env; struct kvm_sregs sregs; struct kvm_regs regs; int ret; @@ -239,8 +244,10 @@ void *kvm_arch_vmalloc(ram_addr_t size) } } =20 -int kvm_arch_insert_sw_breakpoint(CPUS390XState *env, struct kvm_sw_brea= kpoint *bp) +int kvm_arch_insert_sw_breakpoint(CPUState *cs, struct kvm_sw_breakpoint= *bp) { + S390CPU *cpu =3D S390_CPU(cs); + CPUS390XState *env =3D &cpu->env; static const uint8_t diag_501[] =3D {0x83, 0x24, 0x05, 0x01}; =20 if (cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&bp->saved_insn, 4, = 0) || @@ -250,8 +257,10 @@ int kvm_arch_insert_sw_breakpoint(CPUS390XState *env= , struct kvm_sw_breakpoint * return 0; } =20 -int kvm_arch_remove_sw_breakpoint(CPUS390XState *env, struct kvm_sw_brea= kpoint *bp) +int kvm_arch_remove_sw_breakpoint(CPUState *cs, struct kvm_sw_breakpoint= *bp) { + S390CPU *cpu =3D S390_CPU(cs); + CPUS390XState *env =3D &cpu->env; uint8_t t[4]; static const uint8_t diag_501[] =3D {0x83, 0x24, 0x05, 0x01}; =20 @@ -266,17 +275,18 @@ int kvm_arch_remove_sw_breakpoint(CPUS390XState *en= v, struct kvm_sw_breakpoint * return 0; } =20 -void kvm_arch_pre_run(CPUS390XState *env, struct kvm_run *run) +void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run) { } =20 -void kvm_arch_post_run(CPUS390XState *env, struct kvm_run *run) +void kvm_arch_post_run(CPUState *cpu, struct kvm_run *run) { } =20 -int kvm_arch_process_async_events(CPUS390XState *env) +int kvm_arch_process_async_events(CPUState *cs) { - return env->halted; + S390CPU *cpu =3D S390_CPU(cs); + return cpu->env.halted; } =20 void kvm_s390_interrupt_internal(CPUS390XState *env, int type, uint32_t = parm, @@ -565,8 +575,10 @@ static int handle_intercept(CPUS390XState *env) return r; } =20 -int kvm_arch_handle_exit(CPUS390XState *env, struct kvm_run *run) +int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run) { + S390CPU *cpu =3D S390_CPU(cs); + CPUS390XState *env =3D &cpu->env; int ret =3D 0; =20 switch (run->exit_reason) { @@ -587,12 +599,12 @@ int kvm_arch_handle_exit(CPUS390XState *env, struct= kvm_run *run) return ret; } =20 -bool kvm_arch_stop_on_emulation_error(CPUS390XState *env) +bool kvm_arch_stop_on_emulation_error(CPUState *cpu) { return true; } =20 -int kvm_arch_on_sigbus_vcpu(CPUS390XState *env, int code, void *addr) +int kvm_arch_on_sigbus_vcpu(CPUState *cpu, int code, void *addr) { return 1; } --=20 1.7.10.4