| /* |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License, version 2, as |
| * published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
| * |
| * Copyright IBM Corp. 2007 |
| * Copyright 2011 Freescale Semiconductor, Inc. |
| * |
| * Authors: Hollis Blanchard <hollisb@us.ibm.com> |
| */ |
| |
| #include <linux/jiffies.h> |
| #include <linux/hrtimer.h> |
| #include <linux/types.h> |
| #include <linux/string.h> |
| #include <linux/kvm_host.h> |
| #include <linux/clockchips.h> |
| |
| #include <asm/reg.h> |
| #include <asm/time.h> |
| #include <asm/byteorder.h> |
| #include <asm/kvm_ppc.h> |
| #include <asm/disassemble.h> |
| #include <asm/ppc-opcode.h> |
| #include "timing.h" |
| #include "trace.h" |
| |
| #ifdef CONFIG_PPC_FPU |
| static bool kvmppc_check_fp_disabled(struct kvm_vcpu *vcpu) |
| { |
| if (!(kvmppc_get_msr(vcpu) & MSR_FP)) { |
| kvmppc_core_queue_fpunavail(vcpu); |
| return true; |
| } |
| |
| return false; |
| } |
| #endif /* CONFIG_PPC_FPU */ |
| |
| #ifdef CONFIG_VSX |
| static bool kvmppc_check_vsx_disabled(struct kvm_vcpu *vcpu) |
| { |
| if (!(kvmppc_get_msr(vcpu) & MSR_VSX)) { |
| kvmppc_core_queue_vsx_unavail(vcpu); |
| return true; |
| } |
| |
| return false; |
| } |
| #endif /* CONFIG_VSX */ |
| |
| /* |
| * XXX to do: |
| * lfiwax, lfiwzx |
| * vector loads and stores |
| * |
| * Instructions that trap when used on cache-inhibited mappings |
| * are not emulated here: multiple and string instructions, |
| * lq/stq, and the load-reserve/store-conditional instructions. |
| */ |
| int kvmppc_emulate_loadstore(struct kvm_vcpu *vcpu) |
| { |
| struct kvm_run *run = vcpu->run; |
| u32 inst; |
| int ra, rs, rt; |
| enum emulation_result emulated; |
| int advance = 1; |
| |
| /* this default type might be overwritten by subcategories */ |
| kvmppc_set_exit_type(vcpu, EMULATED_INST_EXITS); |
| |
| emulated = kvmppc_get_last_inst(vcpu, INST_GENERIC, &inst); |
| if (emulated != EMULATE_DONE) |
| return emulated; |
| |
| ra = get_ra(inst); |
| rs = get_rs(inst); |
| rt = get_rt(inst); |
| |
| /* |
| * if mmio_vsx_tx_sx_enabled == 0, copy data between |
| * VSR[0..31] and memory |
| * if mmio_vsx_tx_sx_enabled == 1, copy data between |
| * VSR[32..63] and memory |
| */ |
| vcpu->arch.mmio_vsx_tx_sx_enabled = get_tx_or_sx(inst); |
| vcpu->arch.mmio_vsx_copy_nums = 0; |
| vcpu->arch.mmio_vsx_offset = 0; |
| vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_NONE; |
| vcpu->arch.mmio_sp64_extend = 0; |
| vcpu->arch.mmio_sign_extend = 0; |
| |
| switch (get_op(inst)) { |
| case 31: |
| switch (get_xop(inst)) { |
| case OP_31_XOP_LWZX: |
| emulated = kvmppc_handle_load(run, vcpu, rt, 4, 1); |
| break; |
| |
| case OP_31_XOP_LWZUX: |
| emulated = kvmppc_handle_load(run, vcpu, rt, 4, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_31_XOP_LBZX: |
| emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1); |
| break; |
| |
| case OP_31_XOP_LBZUX: |
| emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_31_XOP_STDX: |
| emulated = kvmppc_handle_store(run, vcpu, |
| kvmppc_get_gpr(vcpu, rs), 8, 1); |
| break; |
| |
| case OP_31_XOP_STDUX: |
| emulated = kvmppc_handle_store(run, vcpu, |
| kvmppc_get_gpr(vcpu, rs), 8, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_31_XOP_STWX: |
| emulated = kvmppc_handle_store(run, vcpu, |
| kvmppc_get_gpr(vcpu, rs), 4, 1); |
| break; |
| |
| case OP_31_XOP_STWUX: |
| emulated = kvmppc_handle_store(run, vcpu, |
| kvmppc_get_gpr(vcpu, rs), 4, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_31_XOP_STBX: |
| emulated = kvmppc_handle_store(run, vcpu, |
| kvmppc_get_gpr(vcpu, rs), 1, 1); |
| break; |
| |
| case OP_31_XOP_STBUX: |
| emulated = kvmppc_handle_store(run, vcpu, |
| kvmppc_get_gpr(vcpu, rs), 1, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_31_XOP_LHAX: |
| emulated = kvmppc_handle_loads(run, vcpu, rt, 2, 1); |
| break; |
| |
| case OP_31_XOP_LHAUX: |
| emulated = kvmppc_handle_loads(run, vcpu, rt, 2, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_31_XOP_LHZX: |
| emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1); |
| break; |
| |
| case OP_31_XOP_LHZUX: |
| emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_31_XOP_STHX: |
| emulated = kvmppc_handle_store(run, vcpu, |
| kvmppc_get_gpr(vcpu, rs), 2, 1); |
| break; |
| |
| case OP_31_XOP_STHUX: |
| emulated = kvmppc_handle_store(run, vcpu, |
| kvmppc_get_gpr(vcpu, rs), 2, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_31_XOP_DCBST: |
| case OP_31_XOP_DCBF: |
| case OP_31_XOP_DCBI: |
| /* Do nothing. The guest is performing dcbi because |
| * hardware DMA is not snooped by the dcache, but |
| * emulated DMA either goes through the dcache as |
| * normal writes, or the host kernel has handled dcache |
| * coherence. */ |
| break; |
| |
| case OP_31_XOP_LWBRX: |
| emulated = kvmppc_handle_load(run, vcpu, rt, 4, 0); |
| break; |
| |
| case OP_31_XOP_STWBRX: |
| emulated = kvmppc_handle_store(run, vcpu, |
| kvmppc_get_gpr(vcpu, rs), 4, 0); |
| break; |
| |
| case OP_31_XOP_LHBRX: |
| emulated = kvmppc_handle_load(run, vcpu, rt, 2, 0); |
| break; |
| |
| case OP_31_XOP_STHBRX: |
| emulated = kvmppc_handle_store(run, vcpu, |
| kvmppc_get_gpr(vcpu, rs), 2, 0); |
| break; |
| |
| case OP_31_XOP_LDBRX: |
| emulated = kvmppc_handle_load(run, vcpu, rt, 8, 0); |
| break; |
| |
| case OP_31_XOP_STDBRX: |
| emulated = kvmppc_handle_store(run, vcpu, |
| kvmppc_get_gpr(vcpu, rs), 8, 0); |
| break; |
| |
| case OP_31_XOP_LDX: |
| emulated = kvmppc_handle_load(run, vcpu, rt, 8, 1); |
| break; |
| |
| case OP_31_XOP_LDUX: |
| emulated = kvmppc_handle_load(run, vcpu, rt, 8, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_31_XOP_LWAX: |
| emulated = kvmppc_handle_loads(run, vcpu, rt, 4, 1); |
| break; |
| |
| case OP_31_XOP_LWAUX: |
| emulated = kvmppc_handle_loads(run, vcpu, rt, 4, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| #ifdef CONFIG_PPC_FPU |
| case OP_31_XOP_LFSX: |
| if (kvmppc_check_fp_disabled(vcpu)) |
| return EMULATE_DONE; |
| vcpu->arch.mmio_sp64_extend = 1; |
| emulated = kvmppc_handle_load(run, vcpu, |
| KVM_MMIO_REG_FPR|rt, 4, 1); |
| break; |
| |
| case OP_31_XOP_LFSUX: |
| if (kvmppc_check_fp_disabled(vcpu)) |
| return EMULATE_DONE; |
| vcpu->arch.mmio_sp64_extend = 1; |
| emulated = kvmppc_handle_load(run, vcpu, |
| KVM_MMIO_REG_FPR|rt, 4, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_31_XOP_LFDX: |
| if (kvmppc_check_fp_disabled(vcpu)) |
| return EMULATE_DONE; |
| emulated = kvmppc_handle_load(run, vcpu, |
| KVM_MMIO_REG_FPR|rt, 8, 1); |
| break; |
| |
| case OP_31_XOP_LFDUX: |
| if (kvmppc_check_fp_disabled(vcpu)) |
| return EMULATE_DONE; |
| emulated = kvmppc_handle_load(run, vcpu, |
| KVM_MMIO_REG_FPR|rt, 8, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_31_XOP_LFIWAX: |
| if (kvmppc_check_fp_disabled(vcpu)) |
| return EMULATE_DONE; |
| emulated = kvmppc_handle_loads(run, vcpu, |
| KVM_MMIO_REG_FPR|rt, 4, 1); |
| break; |
| |
| case OP_31_XOP_LFIWZX: |
| if (kvmppc_check_fp_disabled(vcpu)) |
| return EMULATE_DONE; |
| emulated = kvmppc_handle_load(run, vcpu, |
| KVM_MMIO_REG_FPR|rt, 4, 1); |
| break; |
| |
| case OP_31_XOP_STFSX: |
| if (kvmppc_check_fp_disabled(vcpu)) |
| return EMULATE_DONE; |
| vcpu->arch.mmio_sp64_extend = 1; |
| emulated = kvmppc_handle_store(run, vcpu, |
| VCPU_FPR(vcpu, rs), 4, 1); |
| break; |
| |
| case OP_31_XOP_STFSUX: |
| if (kvmppc_check_fp_disabled(vcpu)) |
| return EMULATE_DONE; |
| vcpu->arch.mmio_sp64_extend = 1; |
| emulated = kvmppc_handle_store(run, vcpu, |
| VCPU_FPR(vcpu, rs), 4, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_31_XOP_STFDX: |
| if (kvmppc_check_fp_disabled(vcpu)) |
| return EMULATE_DONE; |
| emulated = kvmppc_handle_store(run, vcpu, |
| VCPU_FPR(vcpu, rs), 8, 1); |
| break; |
| |
| case OP_31_XOP_STFDUX: |
| if (kvmppc_check_fp_disabled(vcpu)) |
| return EMULATE_DONE; |
| emulated = kvmppc_handle_store(run, vcpu, |
| VCPU_FPR(vcpu, rs), 8, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_31_XOP_STFIWX: |
| if (kvmppc_check_fp_disabled(vcpu)) |
| return EMULATE_DONE; |
| emulated = kvmppc_handle_store(run, vcpu, |
| VCPU_FPR(vcpu, rs), 4, 1); |
| break; |
| #endif |
| |
| #ifdef CONFIG_VSX |
| case OP_31_XOP_LXSDX: |
| if (kvmppc_check_vsx_disabled(vcpu)) |
| return EMULATE_DONE; |
| vcpu->arch.mmio_vsx_copy_nums = 1; |
| vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_DWORD; |
| emulated = kvmppc_handle_vsx_load(run, vcpu, |
| KVM_MMIO_REG_VSX|rt, 8, 1, 0); |
| break; |
| |
| case OP_31_XOP_LXSSPX: |
| if (kvmppc_check_vsx_disabled(vcpu)) |
| return EMULATE_DONE; |
| vcpu->arch.mmio_vsx_copy_nums = 1; |
| vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_DWORD; |
| vcpu->arch.mmio_sp64_extend = 1; |
| emulated = kvmppc_handle_vsx_load(run, vcpu, |
| KVM_MMIO_REG_VSX|rt, 4, 1, 0); |
| break; |
| |
| case OP_31_XOP_LXSIWAX: |
| if (kvmppc_check_vsx_disabled(vcpu)) |
| return EMULATE_DONE; |
| vcpu->arch.mmio_vsx_copy_nums = 1; |
| vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_DWORD; |
| emulated = kvmppc_handle_vsx_load(run, vcpu, |
| KVM_MMIO_REG_VSX|rt, 4, 1, 1); |
| break; |
| |
| case OP_31_XOP_LXSIWZX: |
| if (kvmppc_check_vsx_disabled(vcpu)) |
| return EMULATE_DONE; |
| vcpu->arch.mmio_vsx_copy_nums = 1; |
| vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_DWORD; |
| emulated = kvmppc_handle_vsx_load(run, vcpu, |
| KVM_MMIO_REG_VSX|rt, 4, 1, 0); |
| break; |
| |
| case OP_31_XOP_LXVD2X: |
| /* |
| * In this case, the official load/store process is like this: |
| * Step1, exit from vm by page fault isr, then kvm save vsr. |
| * Please see guest_exit_cont->store_fp_state->SAVE_32VSRS |
| * as reference. |
| * |
| * Step2, copy data between memory and VCPU |
| * Notice: for LXVD2X/STXVD2X/LXVW4X/STXVW4X, we use |
| * 2copies*8bytes or 4copies*4bytes |
| * to simulate one copy of 16bytes. |
| * Also there is an endian issue here, we should notice the |
| * layout of memory. |
| * Please see MARCO of LXVD2X_ROT/STXVD2X_ROT as more reference. |
| * If host is little-endian, kvm will call XXSWAPD for |
| * LXVD2X_ROT/STXVD2X_ROT. |
| * So, if host is little-endian, |
| * the postion of memeory should be swapped. |
| * |
| * Step3, return to guest, kvm reset register. |
| * Please see kvmppc_hv_entry->load_fp_state->REST_32VSRS |
| * as reference. |
| */ |
| if (kvmppc_check_vsx_disabled(vcpu)) |
| return EMULATE_DONE; |
| vcpu->arch.mmio_vsx_copy_nums = 2; |
| vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_DWORD; |
| emulated = kvmppc_handle_vsx_load(run, vcpu, |
| KVM_MMIO_REG_VSX|rt, 8, 1, 0); |
| break; |
| |
| case OP_31_XOP_LXVW4X: |
| if (kvmppc_check_vsx_disabled(vcpu)) |
| return EMULATE_DONE; |
| vcpu->arch.mmio_vsx_copy_nums = 4; |
| vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_WORD; |
| emulated = kvmppc_handle_vsx_load(run, vcpu, |
| KVM_MMIO_REG_VSX|rt, 4, 1, 0); |
| break; |
| |
| case OP_31_XOP_LXVDSX: |
| if (kvmppc_check_vsx_disabled(vcpu)) |
| return EMULATE_DONE; |
| vcpu->arch.mmio_vsx_copy_nums = 1; |
| vcpu->arch.mmio_vsx_copy_type = |
| KVMPPC_VSX_COPY_DWORD_LOAD_DUMP; |
| emulated = kvmppc_handle_vsx_load(run, vcpu, |
| KVM_MMIO_REG_VSX|rt, 8, 1, 0); |
| break; |
| |
| case OP_31_XOP_STXSDX: |
| if (kvmppc_check_vsx_disabled(vcpu)) |
| return EMULATE_DONE; |
| vcpu->arch.mmio_vsx_copy_nums = 1; |
| vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_DWORD; |
| emulated = kvmppc_handle_vsx_store(run, vcpu, |
| rs, 8, 1); |
| break; |
| |
| case OP_31_XOP_STXSSPX: |
| if (kvmppc_check_vsx_disabled(vcpu)) |
| return EMULATE_DONE; |
| vcpu->arch.mmio_vsx_copy_nums = 1; |
| vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_DWORD; |
| vcpu->arch.mmio_sp64_extend = 1; |
| emulated = kvmppc_handle_vsx_store(run, vcpu, |
| rs, 4, 1); |
| break; |
| |
| case OP_31_XOP_STXSIWX: |
| if (kvmppc_check_vsx_disabled(vcpu)) |
| return EMULATE_DONE; |
| vcpu->arch.mmio_vsx_offset = 1; |
| vcpu->arch.mmio_vsx_copy_nums = 1; |
| vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_WORD; |
| emulated = kvmppc_handle_vsx_store(run, vcpu, |
| rs, 4, 1); |
| break; |
| |
| case OP_31_XOP_STXVD2X: |
| if (kvmppc_check_vsx_disabled(vcpu)) |
| return EMULATE_DONE; |
| vcpu->arch.mmio_vsx_copy_nums = 2; |
| vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_DWORD; |
| emulated = kvmppc_handle_vsx_store(run, vcpu, |
| rs, 8, 1); |
| break; |
| |
| case OP_31_XOP_STXVW4X: |
| if (kvmppc_check_vsx_disabled(vcpu)) |
| return EMULATE_DONE; |
| vcpu->arch.mmio_vsx_copy_nums = 4; |
| vcpu->arch.mmio_vsx_copy_type = KVMPPC_VSX_COPY_WORD; |
| emulated = kvmppc_handle_vsx_store(run, vcpu, |
| rs, 4, 1); |
| break; |
| #endif /* CONFIG_VSX */ |
| default: |
| emulated = EMULATE_FAIL; |
| break; |
| } |
| break; |
| |
| case OP_LWZ: |
| emulated = kvmppc_handle_load(run, vcpu, rt, 4, 1); |
| break; |
| |
| #ifdef CONFIG_PPC_FPU |
| case OP_STFS: |
| if (kvmppc_check_fp_disabled(vcpu)) |
| return EMULATE_DONE; |
| vcpu->arch.mmio_sp64_extend = 1; |
| emulated = kvmppc_handle_store(run, vcpu, |
| VCPU_FPR(vcpu, rs), |
| 4, 1); |
| break; |
| |
| case OP_STFSU: |
| if (kvmppc_check_fp_disabled(vcpu)) |
| return EMULATE_DONE; |
| vcpu->arch.mmio_sp64_extend = 1; |
| emulated = kvmppc_handle_store(run, vcpu, |
| VCPU_FPR(vcpu, rs), |
| 4, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_STFD: |
| if (kvmppc_check_fp_disabled(vcpu)) |
| return EMULATE_DONE; |
| emulated = kvmppc_handle_store(run, vcpu, |
| VCPU_FPR(vcpu, rs), |
| 8, 1); |
| break; |
| |
| case OP_STFDU: |
| if (kvmppc_check_fp_disabled(vcpu)) |
| return EMULATE_DONE; |
| emulated = kvmppc_handle_store(run, vcpu, |
| VCPU_FPR(vcpu, rs), |
| 8, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| #endif |
| |
| case OP_LD: |
| rt = get_rt(inst); |
| switch (inst & 3) { |
| case 0: /* ld */ |
| emulated = kvmppc_handle_load(run, vcpu, rt, 8, 1); |
| break; |
| case 1: /* ldu */ |
| emulated = kvmppc_handle_load(run, vcpu, rt, 8, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| case 2: /* lwa */ |
| emulated = kvmppc_handle_loads(run, vcpu, rt, 4, 1); |
| break; |
| default: |
| emulated = EMULATE_FAIL; |
| } |
| break; |
| |
| case OP_LWZU: |
| emulated = kvmppc_handle_load(run, vcpu, rt, 4, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_LBZ: |
| emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1); |
| break; |
| |
| case OP_LBZU: |
| emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_STW: |
| emulated = kvmppc_handle_store(run, vcpu, |
| kvmppc_get_gpr(vcpu, rs), |
| 4, 1); |
| break; |
| |
| case OP_STD: |
| rs = get_rs(inst); |
| switch (inst & 3) { |
| case 0: /* std */ |
| emulated = kvmppc_handle_store(run, vcpu, |
| kvmppc_get_gpr(vcpu, rs), 8, 1); |
| break; |
| case 1: /* stdu */ |
| emulated = kvmppc_handle_store(run, vcpu, |
| kvmppc_get_gpr(vcpu, rs), 8, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| default: |
| emulated = EMULATE_FAIL; |
| } |
| break; |
| |
| case OP_STWU: |
| emulated = kvmppc_handle_store(run, vcpu, |
| kvmppc_get_gpr(vcpu, rs), 4, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_STB: |
| emulated = kvmppc_handle_store(run, vcpu, |
| kvmppc_get_gpr(vcpu, rs), 1, 1); |
| break; |
| |
| case OP_STBU: |
| emulated = kvmppc_handle_store(run, vcpu, |
| kvmppc_get_gpr(vcpu, rs), 1, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_LHZ: |
| emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1); |
| break; |
| |
| case OP_LHZU: |
| emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_LHA: |
| emulated = kvmppc_handle_loads(run, vcpu, rt, 2, 1); |
| break; |
| |
| case OP_LHAU: |
| emulated = kvmppc_handle_loads(run, vcpu, rt, 2, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_STH: |
| emulated = kvmppc_handle_store(run, vcpu, |
| kvmppc_get_gpr(vcpu, rs), 2, 1); |
| break; |
| |
| case OP_STHU: |
| emulated = kvmppc_handle_store(run, vcpu, |
| kvmppc_get_gpr(vcpu, rs), 2, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| #ifdef CONFIG_PPC_FPU |
| case OP_LFS: |
| if (kvmppc_check_fp_disabled(vcpu)) |
| return EMULATE_DONE; |
| vcpu->arch.mmio_sp64_extend = 1; |
| emulated = kvmppc_handle_load(run, vcpu, |
| KVM_MMIO_REG_FPR|rt, 4, 1); |
| break; |
| |
| case OP_LFSU: |
| if (kvmppc_check_fp_disabled(vcpu)) |
| return EMULATE_DONE; |
| vcpu->arch.mmio_sp64_extend = 1; |
| emulated = kvmppc_handle_load(run, vcpu, |
| KVM_MMIO_REG_FPR|rt, 4, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| |
| case OP_LFD: |
| if (kvmppc_check_fp_disabled(vcpu)) |
| return EMULATE_DONE; |
| emulated = kvmppc_handle_load(run, vcpu, |
| KVM_MMIO_REG_FPR|rt, 8, 1); |
| break; |
| |
| case OP_LFDU: |
| if (kvmppc_check_fp_disabled(vcpu)) |
| return EMULATE_DONE; |
| emulated = kvmppc_handle_load(run, vcpu, |
| KVM_MMIO_REG_FPR|rt, 8, 1); |
| kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed); |
| break; |
| #endif |
| |
| default: |
| emulated = EMULATE_FAIL; |
| break; |
| } |
| |
| if (emulated == EMULATE_FAIL) { |
| advance = 0; |
| kvmppc_core_queue_program(vcpu, 0); |
| } |
| |
| trace_kvm_ppc_instr(inst, kvmppc_get_pc(vcpu), emulated); |
| |
| /* Advance past emulated instruction. */ |
| if (advance) |
| kvmppc_set_pc(vcpu, kvmppc_get_pc(vcpu) + 4); |
| |
| return emulated; |
| } |
