KVM: x86/mmu: Add a helper function to check if an SPTE needs atomic write

Move conditions in kvm_tdp_mmu_write_spte() to check if an SPTE should
be written atomically or not to a separate function.

This new function, kvm_tdp_mmu_spte_need_atomic_write(),  will be used
in future commits to optimize clearing bits in SPTEs.

Signed-off-by: Vipin Sharma <vipinsh@google.com>
Reviewed-by: David Matlack <dmatlack@google.com>
Reviewed-by: Ben Gardon <bgardon@google.com>
Link: https://lore.kernel.org/r/20230321220021.2119033-2-seanjc@google.com
Signed-off-by: Sean Christopherson <seanjc@google.com>

diff --git a/arch/x86/kvm/mmu/tdp_iter.h b/arch/x86/kvm/mmu/tdp_iter.h
index f0af385..c11c5d0 100644 (file)
--- a/arch/x86/kvm/mmu/tdp_iter.h
+++ b/arch/x86/kvm/mmu/tdp_iter.h
@@ -29,23 +29,29 @@ static inline void __kvm_tdp_mmu_write_spte(tdp_ptep_t sptep, u64 new_spte)
        WRITE_ONCE(*rcu_dereference(sptep), new_spte);
 }
 
+/*
+ * SPTEs must be modified atomically if they are shadow-present, leaf
+ * SPTEs, and have volatile bits, i.e. has bits that can be set outside
+ * of mmu_lock.  The Writable bit can be set by KVM's fast page fault
+ * handler, and Accessed and Dirty bits can be set by the CPU.
+ *
+ * Note, non-leaf SPTEs do have Accessed bits and those bits are
+ * technically volatile, but KVM doesn't consume the Accessed bit of
+ * non-leaf SPTEs, i.e. KVM doesn't care if it clobbers the bit.  This
+ * logic needs to be reassessed if KVM were to use non-leaf Accessed
+ * bits, e.g. to skip stepping down into child SPTEs when aging SPTEs.
+ */
+static inline bool kvm_tdp_mmu_spte_need_atomic_write(u64 old_spte, int level)
+{
+       return is_shadow_present_pte(old_spte) &&
+              is_last_spte(old_spte, level) &&
+              spte_has_volatile_bits(old_spte);
+}
+
 static inline u64 kvm_tdp_mmu_write_spte(tdp_ptep_t sptep, u64 old_spte,
                                         u64 new_spte, int level)
 {
-       /*
-        * Atomically write the SPTE if it is a shadow-present, leaf SPTE with
-        * volatile bits, i.e. has bits that can be set outside of mmu_lock.
-        * The Writable bit can be set by KVM's fast page fault handler, and
-        * Accessed and Dirty bits can be set by the CPU.
-        *
-        * Note, non-leaf SPTEs do have Accessed bits and those bits are
-        * technically volatile, but KVM doesn't consume the Accessed bit of
-        * non-leaf SPTEs, i.e. KVM doesn't care if it clobbers the bit.  This
-        * logic needs to be reassessed if KVM were to use non-leaf Accessed
-        * bits, e.g. to skip stepping down into child SPTEs when aging SPTEs.
-        */
-       if (is_shadow_present_pte(old_spte) && is_last_spte(old_spte, level) &&
-           spte_has_volatile_bits(old_spte))
+       if (kvm_tdp_mmu_spte_need_atomic_write(old_spte, level))
                return kvm_tdp_mmu_write_spte_atomic(sptep, new_spte);
 
        __kvm_tdp_mmu_write_spte(sptep, new_spte);