[PATCH v11 07/23] KVM: x86: Avoid redundant masterclock updates from multiple vCPUs

[David Woodhouse <dwmw2@xxxxxxxxxxxxx>]

From: David Woodhouse <dwmw@xxxxxxxxxxxx>

When a masterclock update is triggered (e.g. by the clocksource change
notifier), KVM_REQ_MASTERCLOCK_UPDATE is set on all vCPUs. Without this
fix, each vCPU independently processes the request and redundantly
re-executes the entire pvclock_update_vm_gtod_copy() sequence, serialized
only by tsc_write_lock. Each redundant re-snapshot of the master clock
reference point introduces potential clock drift.

Fix this by having __kvm_start_pvclock_update() check, after acquiring
the lock, whether the requesting vCPU's KVM_REQ_MASTERCLOCK_UPDATE is
still set. If another vCPU already did the update and cleared it, bail
out. Otherwise, clear the request on all other vCPUs before proceeding.

The caller in vcpu_enter_guest() now uses kvm_test_request() (non-clearing)
since the clearing is done inside __kvm_start_pvclock_update() under the
lock.

kvm_end_pvclock_update() now broadcasts KVM_REQ_CLOCK_UPDATE and clears
KVM_REQ_MCLOCK_INPROGRESS while still inside the interrupts-off lock
section with the seqcount held open. That ordering is load-bearing for
the bail-out path: a vCPU whose request was consumed by another updater
must be guaranteed to observe either the open seqcount or its pending
KVM_REQ_CLOCK_UPDATE before it can enter the guest.

Since the update now consumes pending KVM_REQ_MASTERCLOCK_UPDATE
requests, the Hyper-V reenlightenment notifier must invalidate the
Hyper-V TSC page itself; previously a pending request survived the
notifier and refreshed the page via kvm_update_masterclock() later.

Suggested-by: Dongli Zhang <dongli.zhang@xxxxxxxxxx>
Signed-off-by: David Woodhouse <dwmw@xxxxxxxxxxxx>
Tested-by: Dongli Zhang <dongli.zhang@xxxxxxxxxx>
---
 arch/x86/kvm/msrs.c | 11 ++++++--
 arch/x86/kvm/x86.c  | 67 +++++++++++++++++++++++++++++++++++----------
 2 files changed, 61 insertions(+), 17 deletions(-)

diff --git a/arch/x86/kvm/msrs.c b/arch/x86/kvm/msrs.c
index a2dffa1c706f..26eb30f10c43 100644
--- a/arch/x86/kvm/msrs.c
+++ b/arch/x86/kvm/msrs.c
@@ -1278,10 +1278,15 @@ static void kvm_write_system_time(struct kvm_vcpu 
*vcpu, gpa_t system_time,
        struct kvm_arch *ka = &vcpu->kvm->arch;
 
        if (vcpu->vcpu_id == 0 && !host_initiated) {
-               if (ka->boot_vcpu_runs_old_kvmclock != old_msr)
+               /*
+                * Store the flag before requesting the masterclock update:
+                * the update may now be performed by another vCPU (which
+                * consumes this request), and it must observe the new value.
+                */
+               if (ka->boot_vcpu_runs_old_kvmclock != old_msr) {
+                       ka->boot_vcpu_runs_old_kvmclock = old_msr;
                        kvm_make_request(KVM_REQ_MASTERCLOCK_UPDATE, vcpu);
-
-               ka->boot_vcpu_runs_old_kvmclock = old_msr;
+               }
        }
 
        vcpu->arch.time = system_time;
diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
index e3618d82c099..77bd3e4bfdcd 100644
--- a/arch/x86/kvm/x86.c
+++ b/arch/x86/kvm/x86.c
@@ -1712,10 +1712,39 @@ static void kvm_make_mclock_inprogress_request(struct 
kvm *kvm)
        kvm_make_all_cpus_request(kvm, KVM_REQ_MCLOCK_INPROGRESS);
 }
 
-static void __kvm_start_pvclock_update(struct kvm *kvm)
+static void kvm_clear_mclock_inprogress_request(struct kvm *kvm)
 {
+       struct kvm_vcpu *vcpu;
+       unsigned long i;
+
+       kvm_for_each_vcpu(i, vcpu, kvm)
+               kvm_clear_request(KVM_REQ_MCLOCK_INPROGRESS, vcpu);
+}
+
+static bool __kvm_start_pvclock_update(struct kvm *kvm, struct kvm_vcpu 
*requesting_vcpu)
+{
+       struct kvm_vcpu *vcpu;
+       unsigned long i;
+
        raw_spin_lock_irq(&kvm->arch.tsc_write_lock);
+
+       /*
+        * If another vCPU already did the update while we were waiting
+        * for the lock, our request will have been cleared. Bail out.
+        */
+       if (requesting_vcpu &&
+           !kvm_test_request(KVM_REQ_MASTERCLOCK_UPDATE, requesting_vcpu)) {
+               kvm_clear_mclock_inprogress_request(kvm);
+               raw_spin_unlock_irq(&kvm->arch.tsc_write_lock);
+               return false;
+       }
+
+       /* The update is VM-wide; prevent other vCPUs from redoing it. */
+       kvm_for_each_vcpu(i, vcpu, kvm)
+               kvm_clear_request(KVM_REQ_MASTERCLOCK_UPDATE, vcpu);
+
        write_seqcount_begin(&kvm->arch.pvclock_sc);
+       return true;
 }
 
 static void kvm_start_pvclock_update(struct kvm *kvm)
@@ -1723,7 +1752,7 @@ static void kvm_start_pvclock_update(struct kvm *kvm)
        kvm_make_mclock_inprogress_request(kvm);
 
        /* no guest entries from this point */
-       __kvm_start_pvclock_update(kvm);
+       __kvm_start_pvclock_update(kvm, NULL);
 }
 
 static void kvm_end_pvclock_update(struct kvm *kvm)
@@ -1732,22 +1761,25 @@ static void kvm_end_pvclock_update(struct kvm *kvm)
        struct kvm_vcpu *vcpu;
        unsigned long i;
 
-       write_seqcount_end(&ka->pvclock_sc);
-       raw_spin_unlock_irq(&ka->tsc_write_lock);
        kvm_for_each_vcpu(i, vcpu, kvm)
                kvm_make_request(KVM_REQ_CLOCK_UPDATE, vcpu);
 
        /* guest entries allowed */
-       kvm_for_each_vcpu(i, vcpu, kvm)
-               kvm_clear_request(KVM_REQ_MCLOCK_INPROGRESS, vcpu);
+       kvm_clear_mclock_inprogress_request(kvm);
+
+       write_seqcount_end(&ka->pvclock_sc);
+       raw_spin_unlock_irq(&ka->tsc_write_lock);
 }
 
-static void kvm_update_masterclock(struct kvm *kvm)
+static void kvm_update_masterclock(struct kvm *kvm, struct kvm_vcpu *vcpu)
 {
        kvm_hv_request_tsc_page_update(kvm);
-       kvm_start_pvclock_update(kvm);
-       pvclock_update_vm_gtod_copy(kvm);
-       kvm_end_pvclock_update(kvm);
+       kvm_make_mclock_inprogress_request(kvm);
+
+       if (__kvm_start_pvclock_update(kvm, vcpu)) {
+               pvclock_update_vm_gtod_copy(kvm);
+               kvm_end_pvclock_update(kvm);
+       }
 }
 
 /*
@@ -6848,7 +6880,14 @@ static void kvm_hyperv_tsc_notifier(void)
        kvm_caps.max_guest_tsc_khz = tsc_khz;
 
        list_for_each_entry(kvm, &vm_list, vm_list) {
-               __kvm_start_pvclock_update(kvm);
+               /*
+                * Invalidate the Hyper-V TSC page explicitly: the update
+                * below consumes any pending KVM_REQ_MASTERCLOCK_UPDATE,
+                * which would otherwise have refreshed the page from
+                * kvm_update_masterclock().
+                */
+               kvm_hv_request_tsc_page_update(kvm);
+               __kvm_start_pvclock_update(kvm, NULL);
                pvclock_update_vm_gtod_copy(kvm);
                kvm_end_pvclock_update(kvm);
        }
@@ -8254,8 +8293,8 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu)
                        kvm_mmu_free_obsolete_roots(vcpu);
                if (kvm_check_request(KVM_REQ_MIGRATE_TIMER, vcpu))
                        __kvm_migrate_timers(vcpu);
-               if (kvm_check_request(KVM_REQ_MASTERCLOCK_UPDATE, vcpu))
-                       kvm_update_masterclock(vcpu->kvm);
+               if (kvm_test_request(KVM_REQ_MASTERCLOCK_UPDATE, vcpu))
+                       kvm_update_masterclock(vcpu->kvm, vcpu);
                if (kvm_check_request(KVM_REQ_GLOBAL_CLOCK_UPDATE, vcpu))
                        kvm_gen_kvmclock_update(vcpu);
                if (kvm_check_request(KVM_REQ_CLOCK_UPDATE, vcpu)) {
@@ -9628,7 +9667,7 @@ void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
        vcpu_load(vcpu);
        kvm_synchronize_tsc(vcpu, NULL);
        if (kvm_check_request(KVM_REQ_MASTERCLOCK_UPDATE, vcpu))
-               kvm_update_masterclock(vcpu->kvm);
+               kvm_update_masterclock(vcpu->kvm, NULL);
        vcpu_put(vcpu);
 
        /* poll control enabled by default */
-- 
2.43.0