From mboxrd@z Thu Jan 1 00:00:00 1970 From: ehrhardt@linux.vnet.ibm.com Date: Mon, 14 Apr 2008 12:23:56 +0000 Subject: [kvm-ppc-devel] [PATCH] [1/3] kvmppc: add detailed instruction Message-Id: <12081758423120-git-send-email-ehrhardt@linux.vnet.ibm.com> List-Id: MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: kvm-ppc@vger.kernel.org From: Christian Ehrhardt This extends the kvm_stat reports for kvm on embedded powerpc. Since kvmppc is using emulation (no hardware support yet) this gives people interested in performance a detailed split of the emul_instruction counter already available. This statistic does not cover e.g. operants of the commands, but that way it should have only a small perf impact (never break what you want to measure). This feature is configurable in .config under the kvmppc virtualization itself. Signed-off-by: Christian Ehrhardt --- [diffstat] arch/powerpc/kvm/Kconfig | 8 +++ arch/powerpc/kvm/emulate.c | 61 +++++++++++++++++++++++++++++ arch/powerpc/kvm/powerpc.c | 84 +++++++++++++++++++++++++++++++++++++++++ include/asm-powerpc/kvm_host.h | 40 +++++++++++++++++++ include/asm-powerpc/kvm_ppc.h | 50 ++++++++++++++++++++++++ 5 files changed, 243 insertions(+) diff --git a/arch/powerpc/kvm/Kconfig b/arch/powerpc/kvm/Kconfig --- a/arch/powerpc/kvm/Kconfig +++ b/arch/powerpc/kvm/Kconfig @@ -41,6 +41,14 @@ config KVM_POWERPC_440 ---help--- Provides support for KVM on 440 processors. +config KVM_POWERPC_440_INSTRUCTION_STAT + bool "ppc440 instruction emulation statistics" + depends on KVM && 44x && KVM_POWERPC_440 + ---help--- + Adds the tracking of the different emulated instructions. This is + used to debug performance issues and adds a slight runtime overhead. + If unsure, say N. + config KVM_PPC_VIRTIO bool "Virtio Support" select VIRTIO diff --git a/arch/powerpc/kvm/emulate.c b/arch/powerpc/kvm/emulate.c --- a/arch/powerpc/kvm/emulate.c +++ b/arch/powerpc/kvm/emulate.c @@ -87,6 +87,14 @@ static inline unsigned int get_d(u32 ins static inline unsigned int get_d(u32 inst) { return inst & 0xffff; +} + +static inline void emulinstr_stat(struct kvm_vcpu *vcpu, + enum kvmppc_emulated_instructions kvmppc_emulinstr) +{ +#ifdef CONFIG_KVM_POWERPC_440_INSTRUCTION_STAT + (*(u32 *)((void *)vcpu + kvmppc_emulinstr_offset[kvmppc_emulinstr]))++; +#endif } static int tlbe_is_host_safe(const struct kvm_vcpu *vcpu, @@ -229,6 +237,7 @@ int kvmppc_emulate_instruction(struct kv switch (get_op(inst)) { case 3: /* trap */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_TRAP); if (get_d(inst) = 1) { /* FIXME port to final hypercall API when defined */ printk(KERN_INFO"Guest requested shutdown\n"); @@ -242,6 +251,7 @@ int kvmppc_emulate_instruction(struct kv case 19: switch (get_xop(inst)) { case 50: /* rfi */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_RFI); kvmppc_emul_rfi(vcpu); advance = 0; break; @@ -256,32 +266,39 @@ int kvmppc_emulate_instruction(struct kv switch (get_xop(inst)) { case 83: /* mfmsr */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_MFMSR); rt = get_rt(inst); vcpu->arch.gpr[rt] = vcpu->arch.msr; break; case 87: /* lbzx */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_LBZX); rt = get_rt(inst); emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1); break; case 131: /* wrtee */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_WRTEE); rs = get_rs(inst); vcpu->arch.msr = (vcpu->arch.msr & ~MSR_EE) | (vcpu->arch.gpr[rs] & MSR_EE); break; case 146: /* mtmsr */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_MTMSR); rs = get_rs(inst); kvmppc_set_msr(vcpu, vcpu->arch.gpr[rs]); break; case 163: /* wrteei */ + emulinstr_stat(vcpu, + KVMPPC_EMULATED_INSTRUCTION_WRTEEI); vcpu->arch.msr = (vcpu->arch.msr & ~MSR_EE) | (inst & MSR_EE); break; case 215: /* stbx */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_STBX); rs = get_rs(inst); emulated = kvmppc_handle_store(run, vcpu, vcpu->arch.gpr[rs], @@ -289,6 +306,7 @@ int kvmppc_emulate_instruction(struct kv break; case 247: /* stbux */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_STBUX); rs = get_rs(inst); ra = get_ra(inst); rb = get_rb(inst); @@ -304,11 +322,13 @@ int kvmppc_emulate_instruction(struct kv break; case 279: /* lhzx */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_LHZX); rt = get_rt(inst); emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1); break; case 311: /* lhzux */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_LHZUX); rt = get_rt(inst); ra = get_ra(inst); rb = get_rb(inst); @@ -322,6 +342,7 @@ int kvmppc_emulate_instruction(struct kv break; case 323: /* mfdcr */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_MFDCR); dcrn = get_dcrn(inst); rt = get_rt(inst); @@ -349,6 +370,7 @@ int kvmppc_emulate_instruction(struct kv break; case 339: /* mfspr */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_MFSPR); sprn = get_sprn(inst); rt = get_rt(inst); @@ -438,6 +460,7 @@ int kvmppc_emulate_instruction(struct kv break; case 407: /* sthx */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_STHX); rs = get_rs(inst); ra = get_ra(inst); rb = get_rb(inst); @@ -448,6 +471,7 @@ int kvmppc_emulate_instruction(struct kv break; case 439: /* sthux */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_STHUX); rs = get_rs(inst); ra = get_ra(inst); rb = get_rb(inst); @@ -463,6 +487,7 @@ int kvmppc_emulate_instruction(struct kv break; case 451: /* mtdcr */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_MTDCR); dcrn = get_dcrn(inst); rs = get_rs(inst); @@ -482,6 +507,7 @@ int kvmppc_emulate_instruction(struct kv break; case 467: /* mtspr */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_MTSPR); sprn = get_sprn(inst); rs = get_rs(inst); switch (sprn) { @@ -588,6 +614,7 @@ int kvmppc_emulate_instruction(struct kv break; case 470: /* dcbi */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_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 @@ -596,14 +623,19 @@ int kvmppc_emulate_instruction(struct kv break; case 534: /* lwbrx */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_LWBRX); rt = get_rt(inst); emulated = kvmppc_handle_load(run, vcpu, rt, 4, 0); break; case 566: /* tlbsync */ + emulinstr_stat(vcpu, + KVMPPC_EMULATED_INSTRUCTION_TLBSYNC); break; case 662: /* stwbrx */ + emulinstr_stat(vcpu, + KVMPPC_EMULATED_INSTRUCTION_STWBRX); rs = get_rs(inst); ra = get_ra(inst); rb = get_rb(inst); @@ -614,6 +646,7 @@ int kvmppc_emulate_instruction(struct kv break; case 978: /* tlbwe */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_TLBWE); emulated = kvmppc_emul_tlbwe(vcpu, inst); break; @@ -621,6 +654,7 @@ int kvmppc_emulate_instruction(struct kv int index; unsigned int as = get_mmucr_sts(vcpu); unsigned int pid = get_mmucr_stid(vcpu); + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_TLBSX); rt = get_rt(inst); ra = get_ra(inst); @@ -644,11 +678,14 @@ int kvmppc_emulate_instruction(struct kv break; case 790: /* lhbrx */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_LHBRX); rt = get_rt(inst); emulated = kvmppc_handle_load(run, vcpu, rt, 2, 0); break; case 918: /* sthbrx */ + emulinstr_stat(vcpu, + KVMPPC_EMULATED_INSTRUCTION_STHBRX); rs = get_rs(inst); ra = get_ra(inst); rb = get_rb(inst); @@ -659,6 +696,7 @@ int kvmppc_emulate_instruction(struct kv break; case 966: /* iccci */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_ICCCI); break; default: @@ -670,11 +708,14 @@ int kvmppc_emulate_instruction(struct kv break; case 32: /* lwz */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_LWZ); rt = get_rt(inst); emulated = kvmppc_handle_load(run, vcpu, rt, 4, 1); break; case 33: /* lwzu */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_LWZU); + rt = get_rt(inst); ra = get_ra(inst); rt = get_rt(inst); emulated = kvmppc_handle_load(run, vcpu, rt, 4, 1); @@ -682,11 +723,15 @@ int kvmppc_emulate_instruction(struct kv break; case 34: /* lbz */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_LBZ); + rt = get_rt(inst); rt = get_rt(inst); emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1); break; case 35: /* lbzu */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_LBZU); + rt = get_rt(inst); ra = get_ra(inst); rt = get_rt(inst); emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1); @@ -694,12 +739,16 @@ int kvmppc_emulate_instruction(struct kv break; case 36: /* stw */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_STW); + rt = get_rt(inst); rs = get_rs(inst); emulated = kvmppc_handle_store(run, vcpu, vcpu->arch.gpr[rs], 4, 1); break; case 37: /* stwu */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_STWU); + rt = get_rt(inst); ra = get_ra(inst); rs = get_rs(inst); emulated = kvmppc_handle_store(run, vcpu, vcpu->arch.gpr[rs], @@ -708,12 +757,16 @@ int kvmppc_emulate_instruction(struct kv break; case 38: /* stb */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_STB); + rt = get_rt(inst); rs = get_rs(inst); emulated = kvmppc_handle_store(run, vcpu, vcpu->arch.gpr[rs], 1, 1); break; case 39: /* stbu */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_STBU); + rt = get_rt(inst); ra = get_ra(inst); rs = get_rs(inst); emulated = kvmppc_handle_store(run, vcpu, vcpu->arch.gpr[rs], @@ -722,11 +775,15 @@ int kvmppc_emulate_instruction(struct kv break; case 40: /* lhz */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_LHZ); + rt = get_rt(inst); rt = get_rt(inst); emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1); break; case 41: /* lhzu */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_LHZU); + rt = get_rt(inst); ra = get_ra(inst); rt = get_rt(inst); emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1); @@ -734,12 +791,16 @@ int kvmppc_emulate_instruction(struct kv break; case 44: /* sth */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_STH); + rt = get_rt(inst); rs = get_rs(inst); emulated = kvmppc_handle_store(run, vcpu, vcpu->arch.gpr[rs], 2, 1); break; case 45: /* sthu */ + emulinstr_stat(vcpu, KVMPPC_EMULATED_INSTRUCTION_STHU); + rt = get_rt(inst); ra = get_ra(inst); rs = get_rs(inst); emulated = kvmppc_handle_store(run, vcpu, vcpu->arch.gpr[rs], diff --git a/arch/powerpc/kvm/powerpc.c b/arch/powerpc/kvm/powerpc.c --- a/arch/powerpc/kvm/powerpc.c +++ b/arch/powerpc/kvm/powerpc.c @@ -56,8 +56,92 @@ struct kvm_stats_debugfs_item debugfs_en { "inst_emu", VCPU_STAT(emulated_inst_exits) }, { "dec", VCPU_STAT(dec_exits) }, { "ext_intr", VCPU_STAT(ext_intr_exits) }, +#ifdef CONFIG_KVM_POWERPC_440_INSTRUCTION_STAT + { "instr_trap", VCPU_STAT(instr_trap) }, + { "instr_rfi", VCPU_STAT(instr_rfi) }, + { "instr_mfmsr", VCPU_STAT(instr_mfmsr) }, + { "instr_lbzx", VCPU_STAT(instr_lbzx) }, + { "instr_wrtee", VCPU_STAT(instr_wrtee) }, + { "instr_mtmsr", VCPU_STAT(instr_mtmsr) }, + { "instr_wrteei", VCPU_STAT(instr_wrteei) }, + { "instr_stbx", VCPU_STAT(instr_stbx) }, + { "instr_stbux", VCPU_STAT(instr_stbux) }, + { "instr_lhzx", VCPU_STAT(instr_lhzx) }, + { "instr_lhzux", VCPU_STAT(instr_lhzux) }, + { "instr_mfdcr", VCPU_STAT(instr_mfdcr) }, + { "instr_mfspr", VCPU_STAT(instr_mfspr) }, + { "instr_sthx", VCPU_STAT(instr_sthx) }, + { "instr_sthux", VCPU_STAT(instr_sthux) }, + { "instr_mtdcr", VCPU_STAT(instr_mtdcr) }, + { "instr_mtspr", VCPU_STAT(instr_mtspr) }, + { "instr_dcbi", VCPU_STAT(instr_dcbi) }, + { "instr_lwbrx", VCPU_STAT(instr_lwbrx) }, + { "instr_tlbsync", VCPU_STAT(instr_tlbsync) }, + { "instr_stwbrx", VCPU_STAT(instr_stwbrx) }, + { "instr_tlbwe", VCPU_STAT(instr_tlbwe) }, + { "instr_tlbsx", VCPU_STAT(instr_tlbsx) }, + { "instr_lhbrx", VCPU_STAT(instr_lhbrx) }, + { "instr_sthbrx", VCPU_STAT(instr_sthbrx) }, + { "instr_iccci", VCPU_STAT(instr_iccci) }, + { "instr_lwz", VCPU_STAT(instr_lwz) }, + { "instr_lwzu", VCPU_STAT(instr_lwzu) }, + { "instr_lbz", VCPU_STAT(instr_lbz) }, + { "instr_lbzu", VCPU_STAT(instr_lbzu) }, + { "instr_stw", VCPU_STAT(instr_stw) }, + { "instr_stwu", VCPU_STAT(instr_stwu) }, + { "instr_stb", VCPU_STAT(instr_stb) }, + { "instr_stbu", VCPU_STAT(instr_stbu) }, + { "instr_lhz", VCPU_STAT(instr_lhz) }, + { "instr_lhzu", VCPU_STAT(instr_lhzu) }, + { "instr_sth", VCPU_STAT(instr_sth) }, + { "instr_sthu", VCPU_STAT(instr_sthu) }, +#endif /* CONFIG_KVM_POWERPC_440_INSTRUCTION_STAT */ { NULL } }; + +#ifdef CONFIG_KVM_POWERPC_440_INSTRUCTION_STAT +#define INST_STAT_OFFSET(x) offsetof(struct kvm_vcpu, stat.x) +const int kvmppc_emulinstr_offset[] = { + [KVMPPC_EMULATED_INSTRUCTION_TRAP] = INST_STAT_OFFSET(instr_trap), + [KVMPPC_EMULATED_INSTRUCTION_RFI] = INST_STAT_OFFSET(instr_rfi), + [KVMPPC_EMULATED_INSTRUCTION_MFMSR] = INST_STAT_OFFSET(instr_mfmsr), + [KVMPPC_EMULATED_INSTRUCTION_LBZX] = INST_STAT_OFFSET(instr_lbzx), + [KVMPPC_EMULATED_INSTRUCTION_WRTEE] = INST_STAT_OFFSET(instr_wrtee), + [KVMPPC_EMULATED_INSTRUCTION_MTMSR] = INST_STAT_OFFSET(instr_mtmsr), + [KVMPPC_EMULATED_INSTRUCTION_WRTEEI] = INST_STAT_OFFSET(instr_wrteei), + [KVMPPC_EMULATED_INSTRUCTION_STBX] = INST_STAT_OFFSET(instr_stbx), + [KVMPPC_EMULATED_INSTRUCTION_STBUX] = INST_STAT_OFFSET(instr_stbux), + [KVMPPC_EMULATED_INSTRUCTION_LHZX] = INST_STAT_OFFSET(instr_lhzx), + [KVMPPC_EMULATED_INSTRUCTION_LHZUX] = INST_STAT_OFFSET(instr_lhzux), + [KVMPPC_EMULATED_INSTRUCTION_MFDCR] = INST_STAT_OFFSET(instr_mfdcr), + [KVMPPC_EMULATED_INSTRUCTION_MFSPR] = INST_STAT_OFFSET(instr_mfspr), + [KVMPPC_EMULATED_INSTRUCTION_STHX] = INST_STAT_OFFSET(instr_sthx), + [KVMPPC_EMULATED_INSTRUCTION_STHUX] = INST_STAT_OFFSET(instr_sthux), + [KVMPPC_EMULATED_INSTRUCTION_MTDCR] = INST_STAT_OFFSET(instr_mtdcr), + [KVMPPC_EMULATED_INSTRUCTION_MTSPR] = INST_STAT_OFFSET(instr_mtspr), + [KVMPPC_EMULATED_INSTRUCTION_DCBI] = INST_STAT_OFFSET(instr_dcbi), + [KVMPPC_EMULATED_INSTRUCTION_LWBRX] = INST_STAT_OFFSET(instr_lwbrx), + [KVMPPC_EMULATED_INSTRUCTION_TLBSYNC] = INST_STAT_OFFSET(instr_tlbsync), + [KVMPPC_EMULATED_INSTRUCTION_STWBRX] = INST_STAT_OFFSET(instr_stwbrx), + [KVMPPC_EMULATED_INSTRUCTION_TLBWE] = INST_STAT_OFFSET(instr_tlbwe), + [KVMPPC_EMULATED_INSTRUCTION_TLBSX] = INST_STAT_OFFSET(instr_tlbsx), + [KVMPPC_EMULATED_INSTRUCTION_LHBRX] = INST_STAT_OFFSET(instr_lhbrx), + [KVMPPC_EMULATED_INSTRUCTION_STHBRX] = INST_STAT_OFFSET(instr_sthbrx), + [KVMPPC_EMULATED_INSTRUCTION_ICCCI] = INST_STAT_OFFSET(instr_iccci), + [KVMPPC_EMULATED_INSTRUCTION_LWZ] = INST_STAT_OFFSET(instr_lwz), + [KVMPPC_EMULATED_INSTRUCTION_LWZU] = INST_STAT_OFFSET(instr_lwzu), + [KVMPPC_EMULATED_INSTRUCTION_LBZ] = INST_STAT_OFFSET(instr_lbz), + [KVMPPC_EMULATED_INSTRUCTION_LBZU] = INST_STAT_OFFSET(instr_lbzu), + [KVMPPC_EMULATED_INSTRUCTION_STW] = INST_STAT_OFFSET(instr_stw), + [KVMPPC_EMULATED_INSTRUCTION_STWU] = INST_STAT_OFFSET(instr_stwu), + [KVMPPC_EMULATED_INSTRUCTION_STB] = INST_STAT_OFFSET(instr_stb), + [KVMPPC_EMULATED_INSTRUCTION_STBU] = INST_STAT_OFFSET(instr_stbu), + [KVMPPC_EMULATED_INSTRUCTION_LHZ] = INST_STAT_OFFSET(instr_lhz), + [KVMPPC_EMULATED_INSTRUCTION_LHZU] = INST_STAT_OFFSET(instr_lhzu), + [KVMPPC_EMULATED_INSTRUCTION_STH] = INST_STAT_OFFSET(instr_sth), + [KVMPPC_EMULATED_INSTRUCTION_STHU] = INST_STAT_OFFSET(instr_sthu) +}; +#endif /* CONFIG_KVM_POWERPC_440_INSTRUCTION_STAT */ static int kvmppc_debug; diff --git a/include/asm-powerpc/kvm_host.h b/include/asm-powerpc/kvm_host.h --- a/include/asm-powerpc/kvm_host.h +++ b/include/asm-powerpc/kvm_host.h @@ -59,6 +59,46 @@ struct kvm_vcpu_stat { u32 emulated_inst_exits; u32 dec_exits; u32 ext_intr_exits; +#ifdef CONFIG_KVM_POWERPC_440_INSTRUCTION_STAT + u32 instr_trap; + u32 instr_rfi; + u32 instr_mfmsr; + u32 instr_lbzx; + u32 instr_wrtee; + u32 instr_mtmsr; + u32 instr_wrteei; + u32 instr_stbx; + u32 instr_stbux; + u32 instr_lhzx; + u32 instr_lhzux; + u32 instr_mfdcr; + u32 instr_mfspr; + u32 instr_sthx; + u32 instr_sthux; + u32 instr_mtdcr; + u32 instr_mtspr; + u32 instr_dcbi; + u32 instr_lwbrx; + u32 instr_tlbsync; + u32 instr_stwbrx; + u32 instr_tlbwe; + u32 instr_tlbsx; + u32 instr_lhbrx; + u32 instr_sthbrx; + u32 instr_iccci; + u32 instr_lwz; + u32 instr_lwzu; + u32 instr_lbz; + u32 instr_lbzu; + u32 instr_stw; + u32 instr_stwu; + u32 instr_stb; + u32 instr_stbu; + u32 instr_lhz; + u32 instr_lhzu; + u32 instr_sth; + u32 instr_sthu; +#endif /* CONFIG_KVM_POWERPC_440_INSTRUCTION_STAT */ }; struct tlbe { diff --git a/include/asm-powerpc/kvm_ppc.h b/include/asm-powerpc/kvm_ppc.h --- a/include/asm-powerpc/kvm_ppc.h +++ b/include/asm-powerpc/kvm_ppc.h @@ -41,6 +41,56 @@ enum emulation_result { EMULATE_FAIL, /* can't emulate this instruction */ EMULATE_SHUTDOWN, /* shutdown guest requested (no kvm_run data) */ }; + +enum kvmppc_emulated_instructions { + KVMPPC_EMULATED_INSTRUCTION_TRAP, + KVMPPC_EMULATED_INSTRUCTION_RFI, + KVMPPC_EMULATED_INSTRUCTION_MFMSR, + KVMPPC_EMULATED_INSTRUCTION_LBZX, + KVMPPC_EMULATED_INSTRUCTION_WRTEE, + KVMPPC_EMULATED_INSTRUCTION_MTMSR, + KVMPPC_EMULATED_INSTRUCTION_WRTEEI, + KVMPPC_EMULATED_INSTRUCTION_STBX, + KVMPPC_EMULATED_INSTRUCTION_STBUX, + KVMPPC_EMULATED_INSTRUCTION_LHZX, + KVMPPC_EMULATED_INSTRUCTION_LHZUX, + KVMPPC_EMULATED_INSTRUCTION_MFDCR, + KVMPPC_EMULATED_INSTRUCTION_MFSPR, + KVMPPC_EMULATED_INSTRUCTION_STHX, + KVMPPC_EMULATED_INSTRUCTION_STHUX, + KVMPPC_EMULATED_INSTRUCTION_MTDCR, + KVMPPC_EMULATED_INSTRUCTION_MTSPR, + KVMPPC_EMULATED_INSTRUCTION_DCBI, + KVMPPC_EMULATED_INSTRUCTION_LWBRX, + KVMPPC_EMULATED_INSTRUCTION_TLBSYNC, + KVMPPC_EMULATED_INSTRUCTION_STWBRX, + KVMPPC_EMULATED_INSTRUCTION_TLBWE, + KVMPPC_EMULATED_INSTRUCTION_TLBSX, + KVMPPC_EMULATED_INSTRUCTION_LHBRX, + KVMPPC_EMULATED_INSTRUCTION_STHBRX, + KVMPPC_EMULATED_INSTRUCTION_ICCCI, + KVMPPC_EMULATED_INSTRUCTION_LWZ, + KVMPPC_EMULATED_INSTRUCTION_LWZU, + KVMPPC_EMULATED_INSTRUCTION_LBZ, + KVMPPC_EMULATED_INSTRUCTION_LBZU, + KVMPPC_EMULATED_INSTRUCTION_STW, + KVMPPC_EMULATED_INSTRUCTION_STWU, + KVMPPC_EMULATED_INSTRUCTION_STB, + KVMPPC_EMULATED_INSTRUCTION_STBU, + KVMPPC_EMULATED_INSTRUCTION_LHZ, + KVMPPC_EMULATED_INSTRUCTION_LHZU, + KVMPPC_EMULATED_INSTRUCTION_STH, + KVMPPC_EMULATED_INSTRUCTION_STHU, +}; + +#ifdef CONFIG_KVM_POWERPC_440_INSTRUCTION_STAT +/* + * offset definitions to map&update counters with low runtime overhead + * directly in vcpu->stat.x (no new op/xop -> counter mapping needed, this + * uses the already implemented switch/case in emulate_instruction). +*/ +extern const int kvmppc_emulinstr_offset[]; +#endif /* CONFIG_KVM_POWERPC_440_INSTRUCTION_STAT */ extern const unsigned char exception_priority[]; extern const unsigned char priority_exception[]; ------------------------------------------------------------------------- This SF.net email is sponsored by the 2008 JavaOne(SM) Conference Don't miss this year's exciting event. There's still time to save $100. Use priority code J8TL2D2. http://ad.doubleclick.net/clk;198757673;13503038;p?http://java.sun.com/javaone _______________________________________________ kvm-ppc-devel mailing list kvm-ppc-devel@lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/kvm-ppc-devel