KVM: x86: Use static calls to reduce kvm_pmu_ops overhead
Sean Christopherson
maintainercover KVM: x86: Use static calls to reduce kvm_pmu_ops overhead
This is a minor iteration on Like's v3 to allow kvm_pmu_ops (the global variable, not the struct) be static. I ran the PMU unit tests and compiled, but otherwise it's untested. Strongly recommend waiting for Like to give a thumbs up before applying :-)
[*] https://lore.kernel.org/all/[email protected]
Like Xu (4):
KVM: x86: Move kvm_ops_static_call_update() to x86.c
KVM: x86: Copy kvm_pmu_ops by value to eliminate layer of indirection
KVM: x86: Move .pmu_ops to kvm_x86_init_ops and tag as __initdata
KVM: x86: Use static calls to reduce kvm_pmu_ops overhead
arch/x86/include/asm/kvm-x86-pmu-ops.h | 31 ++++++++++++ arch/x86/include/asm/kvm_host.h | 17 +------ arch/x86/kvm/pmu.c | 66 ++++++++++++++++++-------- arch/x86/kvm/pmu.h | 7 +-- arch/x86/kvm/svm/pmu.c | 2 +- arch/x86/kvm/svm/svm.c | 2 +- arch/x86/kvm/vmx/pmu_intel.c | 2 +- arch/x86/kvm/vmx/vmx.c | 2 +- arch/x86/kvm/x86.c | 21 +++++++- 9 files changed, 102 insertions(+), 48 deletions(-) create mode 100644 arch/x86/include/asm/kvm-x86-pmu-ops.h
base-commit: 19164ad08bf668bca4f4bfbaacaa0a47c1b737a6
Signature · 1 line
2.35.1.1021.g381101b075-goog
Sean Christopherson
maintainerPATCH 1/4 KVM: x86: Move kvm_ops_static_call_update() to x86.c
From: Like Xu <[email protected]>
The kvm_ops_static_call_update() is defined in kvm_host.h. That's completely unnecessary, it should have exactly one caller, kvm_arch_hardware_setup(). Move the helper to x86.c and have it do the actual memcpy() of the ops in addition to the static call updates. This will also allow for cleanly giving kvm_pmu_ops static_call treatment.
--- arch/x86/include/asm/kvm_host.h | 14 -------------- arch/x86/kvm/x86.c | 19 +++++++++++++++++-- 2 files changed, 17 insertions(+), 16 deletions(-)
arch/x86/include/asm/kvm_host.h +0 -14
@@ -1557,20 +1557,6 @@ extern struct kvm_x86_ops kvm_x86_ops;#define KVM_X86_OP_OPTIONAL_RET0 KVM_X86_OP#include <asm/kvm-x86-ops.h> -static inline void kvm_ops_static_call_update (void ) -{ -#define __KVM_X86_OP (func) \ - static_call_update(kvm_x86_##func, kvm_x86_ops.func); -#define KVM_X86_OP (func) \ - WARN_ON(!kvm_x86_ops.func); __KVM_X86_OP(func) -#define KVM_X86_OP_OPTIONAL __KVM_X86_OP -#define KVM_X86_OP_OPTIONAL_RET0 (func) \ - static_call_update(kvm_x86_##func, (void *)kvm_x86_ops.func ? : \ - (void *)__static_call_return0); -#include <asm/kvm-x86-ops.h> -#undef __KVM_X86_OP -} -#define __KVM_HAVE_ARCH_VM_ALLOCstatic inline struct kvm *kvm_arch_alloc_vm (void ) {
arch/x86/kvm/x86.c +17 -2
@@ -11595,6 +11595,22 @@ void kvm_arch_hardware_disable(void)drop_user_return_notifiers (); } +static inline void kvm_ops_update (struct kvm_x86_init_ops *ops) +{ +memcpy (&kvm_x86_ops, ops->runtime_ops,sizeof (kvm_x86_ops)); + +#define __KVM_X86_OP (func) \ + static_call_update(kvm_x86_##func, kvm_x86_ops.func); +#define KVM_X86_OP (func) \ + WARN_ON(!kvm_x86_ops.func); __KVM_X86_OP(func) +#define KVM_X86_OP_OPTIONAL __KVM_X86_OP +#define KVM_X86_OP_OPTIONAL_RET0 (func) \ + static_call_update(kvm_x86_##func, (void *)kvm_x86_ops.func ? : \ + (void *)__static_call_return0); +#include <asm/kvm-x86-ops.h> +#undef __KVM_X86_OP +} +int kvm_arch_hardware_setup (void *opaque) {struct kvm_x86_init_ops *ops = opaque;
@@ -11609,8 +11625,7 @@ int kvm_arch_hardware_setup(void *opaque)if (r !=0 )return r; -memcpy (&kvm_x86_ops, ops->runtime_ops,sizeof (kvm_x86_ops)); -kvm_ops_static_call_update (); +kvm_ops_update (ops);kvm_register_perf_callbacks (ops->handle_intel_pt_intr);
Signature · 1 line
2.35.1.1021.g381101b075-goog
Sean Christopherson
maintainerPATCH 2/4 KVM: x86: Copy kvm_pmu_ops by value to eliminate layer of indirection
In reply to Sean ChristophersonFrom: Like Xu <[email protected]>
Replace the kvm_pmu_ops pointer in common x86 with an instance of the struct to save one pointer dereference when invoking functions. Copy the struct by value to set the ops during kvm_init().
--- arch/x86/kvm/pmu.c | 54 ++++++++++++++++++++++++++++------------------ arch/x86/kvm/pmu.h | 7 ++---- arch/x86/kvm/x86.c | 2 ++ 3 files changed, 37 insertions(+), 26 deletions(-)
arch/x86/kvm/pmu.c +33 -21
@@ -49,6 +49,18 @@* * AMD: [0 .. AMD64_NUM_COUNTERS-1] <=> gp counters */ +static struct kvm_pmu_ops kvm_pmu_ops__read_mostly ; + +void kvm_pmu_ops_update (const struct kvm_pmu_ops *pmu_ops) +{ +memcpy (&kvm_pmu_ops, pmu_ops,sizeof (kvm_pmu_ops)); +} + +static inline bool pmc_is_enabled (struct kvm_pmc *pmc) +{ +return kvm_pmu_ops.pmc_is_enabled (pmc); +} +static void kvm_pmi_trigger_fn (struct irq_work *irq_work) { struct kvm_pmu *pmu = container_of(irq_work, struct kvm_pmu, irq_work);
@@ -213,7 +225,7 @@ void reprogram_gp_counter(struct kvm_pmc *pmc, u64 eventsel) ARCH_PERFMON_EVENTSEL_CMASK | HSW_IN_TX | HSW_IN_TX_CHECKPOINTED))) { - config = kvm_x86_ops.pmu_ops->pmc_perf_hw_id (pmc); + config = kvm_pmu_ops.pmc_perf_hw_id (pmc);if (config !=PERF_COUNT_HW_MAX ) type =PERF_TYPE_HARDWARE ; }
@@ -263,7 +275,7 @@ void reprogram_fixed_counter(struct kvm_pmc *pmc, u8 ctrl, int idx) pmc->current_config = (u64 )ctrl;pmc_reprogram_counter (pmc,PERF_TYPE_HARDWARE , - kvm_x86_ops.pmu_ops->pmc_perf_hw_id (pmc), + kvm_pmu_ops.pmc_perf_hw_id (pmc), !(en_field &0x2 ),/* exclude user */ !(en_field &0x1 ),/* exclude kernel */ pmi);
@@ -272,7 +284,7 @@ EXPORT_SYMBOL_GPL(reprogram_fixed_counter);void reprogram_counter (struct kvm_pmu *pmu,int pmc_idx) { -struct kvm_pmc *pmc = kvm_x86_ops.pmu_ops->pmc_idx_to_pmc (pmu, pmc_idx); +struct kvm_pmc *pmc = kvm_pmu_ops.pmc_idx_to_pmc (pmu, pmc_idx);if (!pmc)return ;
@@ -294,7 +306,7 @@ void kvm_pmu_handle_event(struct kvm_vcpu *vcpu)int bit;for_each_set_bit (bit, pmu->reprogram_pmi,X86_PMC_IDX_MAX ) { -struct kvm_pmc *pmc = kvm_x86_ops.pmu_ops->pmc_idx_to_pmc (pmu, bit); +struct kvm_pmc *pmc = kvm_pmu_ops.pmc_idx_to_pmc (pmu, bit);if (unlikely (!pmc || !pmc->perf_event)) {clear_bit (bit, pmu->reprogram_pmi);
@@ -316,7 +328,7 @@ void kvm_pmu_handle_event(struct kvm_vcpu *vcpu)/* check if idx is a valid index to access PMU */ bool kvm_pmu_is_valid_rdpmc_ecx (struct kvm_vcpu *vcpu,unsigned int idx) { -return kvm_x86_ops.pmu_ops->is_valid_rdpmc_ecx (vcpu, idx); +return kvm_pmu_ops.is_valid_rdpmc_ecx (vcpu, idx); }bool is_vmware_backdoor_pmc (u32 pmc_idx)
@@ -366,7 +378,7 @@ int kvm_pmu_rdpmc(struct kvm_vcpu *vcpu, unsigned idx, u64 *data)if (is_vmware_backdoor_pmc (idx))return kvm_pmu_rdpmc_vmware (vcpu, idx, data); - pmc = kvm_x86_ops.pmu_ops->rdpmc_ecx_to_pmc (vcpu, idx, &mask); + pmc = kvm_pmu_ops.rdpmc_ecx_to_pmc (vcpu, idx, &mask);if (!pmc)return 1 ;
@@ -382,22 +394,22 @@ int kvm_pmu_rdpmc(struct kvm_vcpu *vcpu, unsigned idx, u64 *data)void kvm_pmu_deliver_pmi (struct kvm_vcpu *vcpu) {if (lapic_in_kernel (vcpu)) { -if (kvm_x86_ops.pmu_ops->deliver_pmi) - kvm_x86_ops.pmu_ops->deliver_pmi (vcpu); +if (kvm_pmu_ops.deliver_pmi) + kvm_pmu_ops.deliver_pmi (vcpu);kvm_apic_local_deliver (vcpu->arch.apic,APIC_LVTPC ); } }bool kvm_pmu_is_valid_msr (struct kvm_vcpu *vcpu,u32 msr) { -return kvm_x86_ops.pmu_ops->msr_idx_to_pmc (vcpu, msr) || - kvm_x86_ops.pmu_ops->is_valid_msr (vcpu, msr); +return kvm_pmu_ops.msr_idx_to_pmc (vcpu, msr) || + kvm_pmu_ops.is_valid_msr (vcpu, msr); }static void kvm_pmu_mark_pmc_in_use (struct kvm_vcpu *vcpu,u32 msr) {struct kvm_pmu *pmu =vcpu_to_pmu (vcpu); -struct kvm_pmc *pmc = kvm_x86_ops.pmu_ops->msr_idx_to_pmc (vcpu, msr); +struct kvm_pmc *pmc = kvm_pmu_ops.msr_idx_to_pmc (vcpu, msr);if (pmc)__set_bit (pmc->idx, pmu->pmc_in_use);
@@ -405,13 +417,13 @@ static void kvm_pmu_mark_pmc_in_use(struct kvm_vcpu *vcpu, u32 msr)int kvm_pmu_get_msr (struct kvm_vcpu *vcpu,struct msr_data *msr_info) { -return kvm_x86_ops.pmu_ops->get_msr (vcpu, msr_info); +return kvm_pmu_ops.get_msr (vcpu, msr_info); }int kvm_pmu_set_msr (struct kvm_vcpu *vcpu,struct msr_data *msr_info) {kvm_pmu_mark_pmc_in_use (vcpu, msr_info->index); -return kvm_x86_ops.pmu_ops->set_msr (vcpu, msr_info); +return kvm_pmu_ops.set_msr (vcpu, msr_info); }/* refresh PMU settings. This function generally is called when underlying
@@ -420,7 +432,7 @@ int kvm_pmu_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr_info)*/ void kvm_pmu_refresh (struct kvm_vcpu *vcpu) { - kvm_x86_ops.pmu_ops->refresh (vcpu); + kvm_pmu_ops.refresh (vcpu); }void kvm_pmu_reset (struct kvm_vcpu *vcpu)
@@ -428,7 +440,7 @@ void kvm_pmu_reset(struct kvm_vcpu *vcpu)struct kvm_pmu *pmu =vcpu_to_pmu (vcpu);irq_work_sync (&pmu->irq_work); - kvm_x86_ops.pmu_ops->reset (vcpu); + kvm_pmu_ops.reset (vcpu); }void kvm_pmu_init (struct kvm_vcpu *vcpu)
@@ -436,7 +448,7 @@ void kvm_pmu_init(struct kvm_vcpu *vcpu)struct kvm_pmu *pmu =vcpu_to_pmu (vcpu);memset (pmu,0 ,sizeof (*pmu)); - kvm_x86_ops.pmu_ops->init (vcpu); + kvm_pmu_ops.init (vcpu);init_irq_work (&pmu->irq_work, kvm_pmi_trigger_fn); pmu->event_count =0 ; pmu->need_cleanup = false;
@@ -468,14 +480,14 @@ void kvm_pmu_cleanup(struct kvm_vcpu *vcpu) pmu->pmc_in_use, X86_PMC_IDX_MAX);for_each_set_bit (i, bitmask,X86_PMC_IDX_MAX ) { - pmc = kvm_x86_ops.pmu_ops->pmc_idx_to_pmc (pmu, i); + pmc = kvm_pmu_ops.pmc_idx_to_pmc (pmu, i);if (pmc && pmc->perf_event && !pmc_speculative_in_use (pmc))pmc_stop_counter (pmc); } -if (kvm_x86_ops.pmu_ops->cleanup) - kvm_x86_ops.pmu_ops->cleanup (vcpu); +if (kvm_pmu_ops.cleanup) + kvm_pmu_ops.cleanup (vcpu);bitmap_zero (pmu->pmc_in_use,X86_PMC_IDX_MAX ); }
@@ -505,7 +517,7 @@ static inline bool eventsel_match_perf_hw_id(struct kvm_pmc *pmc,unsigned int config; pmc->eventsel &= (ARCH_PERFMON_EVENTSEL_EVENT |ARCH_PERFMON_EVENTSEL_UMASK ); - config = kvm_x86_ops.pmu_ops->pmc_perf_hw_id (pmc); + config = kvm_pmu_ops.pmc_perf_hw_id (pmc); pmc->eventsel = old_eventsel;return config == perf_hw_id; }
@@ -533,7 +545,7 @@ void kvm_pmu_trigger_event(struct kvm_vcpu *vcpu, u64 perf_hw_id)int i;for_each_set_bit (i, pmu->all_valid_pmc_idx,X86_PMC_IDX_MAX ) { - pmc = kvm_x86_ops.pmu_ops->pmc_idx_to_pmc (pmu, i); + pmc = kvm_pmu_ops.pmc_idx_to_pmc (pmu, i);if (!pmc || !pmc_is_enabled (pmc) || !pmc_speculative_in_use (pmc))continue ;
arch/x86/kvm/pmu.h +2 -5
@@ -41,6 +41,8 @@ struct kvm_pmu_ops {void (*cleanup)(struct kvm_vcpu *vcpu); }; +void kvm_pmu_ops_update (const struct kvm_pmu_ops *pmu_ops); +static inline u64 pmc_bitmask (struct kvm_pmc *pmc) {struct kvm_pmu *pmu =pmc_to_pmu (pmc);
@@ -88,11 +90,6 @@ static inline bool pmc_is_fixed(struct kvm_pmc *pmc)return pmc->type ==KVM_PMC_FIXED ; } -static inline bool pmc_is_enabled (struct kvm_pmc *pmc) -{ -return kvm_x86_ops.pmu_ops->pmc_is_enabled (pmc); -} -static inline bool kvm_valid_perf_global_ctrl (struct kvm_pmu *pmu,u64 data) {
arch/x86/kvm/x86.c +2 -0
@@ -11609,6 +11609,8 @@ static inline void kvm_ops_update(struct kvm_x86_init_ops *ops) (void *)__static_call_return0);#include <asm/kvm-x86-ops.h> #undef __KVM_X86_OP + +kvm_pmu_ops_update (ops->runtime_ops->pmu_ops); }int kvm_arch_hardware_setup (void *opaque)
Signature · 1 line
2.35.1.1021.g381101b075-goog
Sean Christopherson
maintainerPATCH 3/4 KVM: x86: Move .pmu_ops to kvm_x86_init_ops and tag as __initdata
In reply to Sean ChristophersonFrom: Like Xu <[email protected]>
The pmu_ops should be moved to kvm_x86_init_ops and tagged as __initdata. That'll save those precious few bytes, and more importantly make the original ops unreachable, i.e. make it harder to sneak in post-init modification bugs.
--- arch/x86/include/asm/kvm_host.h | 3 +-- arch/x86/kvm/svm/pmu.c | 2 +- arch/x86/kvm/svm/svm.c | 2 +- arch/x86/kvm/vmx/pmu_intel.c | 2 +- arch/x86/kvm/vmx/vmx.c | 2 +- arch/x86/kvm/x86.c | 2 +- 6 files changed, 6 insertions(+), 7 deletions(-)
arch/x86/include/asm/kvm_host.h +1 -2
@@ -1464,8 +1464,6 @@ struct kvm_x86_ops {int cpu_dirty_log_size;void (*update_cpu_dirty_logging)(struct kvm_vcpu *vcpu); -/* pmu operations of sub-arch */ -const struct kvm_pmu_ops *pmu_ops;const struct kvm_x86_nested_ops *nested_ops;void (*vcpu_blocking)(struct kvm_vcpu *vcpu);
@@ -1536,6 +1534,7 @@ struct kvm_x86_init_ops {unsigned int (*handle_intel_pt_intr)(void );struct kvm_x86_ops *runtime_ops; +struct kvm_pmu_ops *pmu_ops; };struct kvm_arch_async_pf {
arch/x86/kvm/svm/pmu.c +1 -1
@@ -319,7 +319,7 @@ static void amd_pmu_reset(struct kvm_vcpu *vcpu) } } -struct kvm_pmu_ops amd_pmu_ops = { +struct kvm_pmu_ops amd_pmu_ops__initdata = { .pmc_perf_hw_id = amd_pmc_perf_hw_id, .pmc_is_enabled = amd_pmc_is_enabled, .pmc_idx_to_pmc = amd_pmc_idx_to_pmc,
arch/x86/kvm/svm/svm.c +1 -1
@@ -4625,7 +4625,6 @@ static struct kvm_x86_ops svm_x86_ops __initdata = { .sched_in = svm_sched_in, - .pmu_ops = &amd_pmu_ops, .nested_ops = &svm_nested_ops, .deliver_interrupt = svm_deliver_interrupt,
@@ -4906,6 +4905,7 @@ static struct kvm_x86_init_ops svm_init_ops __initdata = { .check_processor_compatibility = svm_check_processor_compat, .runtime_ops = &svm_x86_ops, + .pmu_ops = &amd_pmu_ops, };static int __init svm_init (void )
arch/x86/kvm/vmx/pmu_intel.c +1 -1
@@ -723,7 +723,7 @@ static void intel_pmu_cleanup(struct kvm_vcpu *vcpu)intel_pmu_release_guest_lbr_event (vcpu); } -struct kvm_pmu_ops intel_pmu_ops = { +struct kvm_pmu_ops intel_pmu_ops__initdata = { .pmc_perf_hw_id = intel_pmc_perf_hw_id, .pmc_is_enabled = intel_pmc_is_enabled, .pmc_idx_to_pmc = intel_pmc_idx_to_pmc,
arch/x86/kvm/vmx/vmx.c +1 -1
@@ -7823,7 +7823,6 @@ static struct kvm_x86_ops vmx_x86_ops __initdata = { .cpu_dirty_log_size = PML_ENTITY_NUM, .update_cpu_dirty_logging = vmx_update_cpu_dirty_logging, - .pmu_ops = &intel_pmu_ops, .nested_ops = &vmx_nested_ops, .pi_update_irte = vmx_pi_update_irte,
@@ -8078,6 +8077,7 @@ static struct kvm_x86_init_ops vmx_init_ops __initdata = { .handle_intel_pt_intr = NULL, .runtime_ops = &vmx_x86_ops, + .pmu_ops = &intel_pmu_ops, };static void vmx_cleanup_l1d_flush (void )
arch/x86/kvm/x86.c +1 -1
@@ -11610,7 +11610,7 @@ static inline void kvm_ops_update(struct kvm_x86_init_ops *ops)#include <asm/kvm-x86-ops.h> #undef __KVM_X86_OP -kvm_pmu_ops_update (ops->runtime_ops->pmu_ops); +kvm_pmu_ops_update (ops->pmu_ops); }int kvm_arch_hardware_setup (void *opaque)
Signature · 1 line
2.35.1.1021.g381101b075-goog
Sean Christopherson
maintainerPATCH 4/4 KVM: x86: Use static calls to reduce kvm_pmu_ops overhead
In reply to Sean ChristophersonFrom: Like Xu <[email protected]>
Use static calls to improve kvm_pmu_ops performance, following the same pattern and naming scheme used by kvm-x86-ops.h.
Here are the worst fenced_rdtsc() cycles numbers for the kvm_pmu_ops functions that is most often called (up to 7 digits of calls) when running a single perf test case in a guest on an ICX 2.70GHz host (mitigations=on):
| legacy | static call
------------------------------------------------------------
.pmc_idx_to_pmc | 1304840 | 994872 (+23%) .pmc_is_enabled | 978670 | 1011750 (-3%) .msr_idx_to_pmc | 47828 | 41690 (+12%)
.is_valid_msr | 28786 | 30108 (-4%)
--- arch/x86/include/asm/kvm-x86-pmu-ops.h | 31 ++++++++++++++ arch/x86/kvm/pmu.c | 56 ++++++++++++++++---------- 2 files changed, 65 insertions(+), 22 deletions(-) create mode 100644 arch/x86/include/asm/kvm-x86-pmu-ops.h
arch/x86/include/asm/kvm-x86-pmu-ops.h new file +31 -0
@@ -0,0 +1,31 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#if !defined(KVM_X86_PMU_OP ) || !defined(KVM_X86_PMU_OP_OPTIONAL ) +BUILD_BUG_ON(1) +#endif + +/* +* KVM_X86_PMU_OP() and KVM_X86_PMU_OP_OPTIONAL() are used to help generate +* both DECLARE/DEFINE_STATIC_CALL() invocations and +* "static_call_update()" calls. +* +* KVM_X86_PMU_OP_OPTIONAL() can be used for those functions that can have +* a NULL definition, for example if "static_call_cond()" will be used +* at the call sites. +*/ +KVM_X86_PMU_OP(pmc_perf_hw_id) +KVM_X86_PMU_OP(pmc_is_enabled) +KVM_X86_PMU_OP(pmc_idx_to_pmc) +KVM_X86_PMU_OP(rdpmc_ecx_to_pmc) +KVM_X86_PMU_OP(msr_idx_to_pmc) +KVM_X86_PMU_OP(is_valid_rdpmc_ecx) +KVM_X86_PMU_OP(is_valid_msr) +KVM_X86_PMU_OP(get_msr) +KVM_X86_PMU_OP(set_msr) +KVM_X86_PMU_OP(refresh) +KVM_X86_PMU_OP(init) +KVM_X86_PMU_OP(reset) +KVM_X86_PMU_OP_OPTIONAL(deliver_pmi) +KVM_X86_PMU_OP_OPTIONAL(cleanup) + +#undef KVM_X86_PMU_OP +#undef KVM_X86_PMU_OP_OPTIONAL
arch/x86/kvm/pmu.c +34 -22
174 lines not on this page · raw message
Signature · 1 line
2.35.1.1021.g381101b075-goog
Quoted 4 lines · Sean Christopherson
This is a minor iteration on Like's v3 to allow
kvm_pmu_ops(the global variable, not the struct) be static. I ran the PMU unit tests and compiled, but otherwise it's untested. Strongly recommend waiting for Like to give a thumbs up before applying :-)
Uh, thank you for picking up this optimization and it passes my test cases.
Quoted 23 lines
[*] https://lore.kernel.org/all/[email protected]
Like Xu (4):
KVM: x86: Movekvm_ops_static_call_update()tox86.c
KVM: x86: Copykvm_pmu_opsby value to eliminate layer of indirection
KVM: x86: Move .pmu_ops tokvm_x86_init_opsand tag as__initdata
KVM: x86: Use static calls to reducekvm_pmu_opsoverheadarch/x86/include/asm/kvm-x86-pmu-ops.h | 31 ++++++++++++ arch/x86/include/asm/kvm_host.h | 17 +------ arch/x86/kvm/pmu.c | 66 ++++++++++++++++++-------- arch/x86/kvm/pmu.h | 7 +-- arch/x86/kvm/svm/pmu.c | 2 +- arch/x86/kvm/svm/svm.c | 2 +- arch/x86/kvm/vmx/pmu_intel.c | 2 +- arch/x86/kvm/vmx/vmx.c | 2 +- arch/x86/kvm/x86.c | 21 +++++++- 9 files changed, 102 insertions(+), 48 deletions(-)create mode 100644
arch/x86/include/asm/kvm-x86-pmu-ops.hbase-commit:
19164ad08bf668bca4f4bfbaacaa0a47c1b737a6
Queued, thanks.
Paolo