KVM: x86/tdp_mmu: Rename REMOVED_SPTE to FROZEN_SPTE

Rename REMOVED_SPTE to FROZEN_SPTE so that it can be used for other
multi-part operations.

REMOVED_SPTE is used as a non-present intermediate value for multi-part
operations that can happen when a thread doesn't have an MMU write lock.
Today these operations are when removing PTEs.

However, future changes will want to use the same concept for setting a
PTE. In that case the REMOVED_SPTE name does not quite fit. So rename it
to FROZEN_SPTE so it can be used for both types of operations.

Also rename the relevant helpers and comments that refer to "removed"
within the context of the SPTE value. Take care to not update naming
referring the "remove" operations, which are still distinct.

Suggested-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Rick Edgecombe <rick.p.edgecombe@intel.com>
Message-ID: <20240619223614.290657-2-rick.p.edgecombe@intel.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

diff --git a/arch/x86/kvm/mmu/mmu.c b/arch/x86/kvm/mmu/mmu.c
index 1432deb75cbb2eb5ce743551fde90ce9b0fa66e2..470d14b2c3d9d365dee36a594c390c3142219e67 100644 (file)
--- a/arch/x86/kvm/mmu/mmu.c
+++ b/arch/x86/kvm/mmu/mmu.c
@@ -3458,7 +3458,7 @@ static int fast_page_fault(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault)
                 * available as the vCPU holds a reference to its root(s).
                 */
                if (WARN_ON_ONCE(!sptep))
-                       spte = REMOVED_SPTE;
+                       spte = FROZEN_SPTE;
 
                if (!is_shadow_present_pte(spte))
                        break;

diff --git a/arch/x86/kvm/mmu/spte.c b/arch/x86/kvm/mmu/spte.c
index a5e014d7bc62e84d5a0ceb2946b89798a7426c2d..59cac37615b6fe7ff4910c0fa43e974a0fb38b2c 100644 (file)
--- a/arch/x86/kvm/mmu/spte.c
+++ b/arch/x86/kvm/mmu/spte.c
@@ -383,7 +383,7 @@ void kvm_mmu_set_mmio_spte_mask(u64 mmio_value, u64 mmio_mask, u64 access_mask)
         * not set any RWX bits.
         */
        if (WARN_ON((mmio_value & mmio_mask) != mmio_value) ||
-           WARN_ON(mmio_value && (REMOVED_SPTE & mmio_mask) == mmio_value))
+           WARN_ON(mmio_value && (FROZEN_SPTE & mmio_mask) == mmio_value))
                mmio_value = 0;
 
        if (!mmio_value)

diff --git a/arch/x86/kvm/mmu/spte.h b/arch/x86/kvm/mmu/spte.h
index 52fa004a1fbc9f3dbe77b2bb8ef93d2cb74b341b..ef793c459b05b1c5d475c5627b5e636a6236a16f 100644 (file)
--- a/arch/x86/kvm/mmu/spte.h
+++ b/arch/x86/kvm/mmu/spte.h
@@ -202,7 +202,7 @@ extern u64 __read_mostly shadow_nonpresent_or_rsvd_mask;
 
 /*
  * If a thread running without exclusive control of the MMU lock must perform a
- * multi-part operation on an SPTE, it can set the SPTE to REMOVED_SPTE as a
+ * multi-part operation on an SPTE, it can set the SPTE to FROZEN_SPTE as a
  * non-present intermediate value. Other threads which encounter this value
  * should not modify the SPTE.
  *
@@ -212,14 +212,14 @@ extern u64 __read_mostly shadow_nonpresent_or_rsvd_mask;
  *
  * Only used by the TDP MMU.
  */
-#define REMOVED_SPTE   (SHADOW_NONPRESENT_VALUE | 0x5a0ULL)
+#define FROZEN_SPTE    (SHADOW_NONPRESENT_VALUE | 0x5a0ULL)
 
 /* Removed SPTEs must not be misconstrued as shadow present PTEs. */
-static_assert(!(REMOVED_SPTE & SPTE_MMU_PRESENT_MASK));
+static_assert(!(FROZEN_SPTE & SPTE_MMU_PRESENT_MASK));
 
-static inline bool is_removed_spte(u64 spte)
+static inline bool is_frozen_spte(u64 spte)
 {
-       return spte == REMOVED_SPTE;
+       return spte == FROZEN_SPTE;
 }
 
 /* Get an SPTE's index into its parent's page table (and the spt array). */

diff --git a/arch/x86/kvm/mmu/tdp_mmu.c b/arch/x86/kvm/mmu/tdp_mmu.c
index effb70f7dcbacc46fd89933a08793f3908e0e71c..d57e0dae4065dfb8041bec6755c73196bd7c21d1 100644 (file)
--- a/arch/x86/kvm/mmu/tdp_mmu.c
+++ b/arch/x86/kvm/mmu/tdp_mmu.c
@@ -365,8 +365,8 @@ static void handle_removed_pt(struct kvm *kvm, tdp_ptep_t pt, bool shared)
                         * value to the removed SPTE value.
                         */
                        for (;;) {
-                               old_spte = kvm_tdp_mmu_write_spte_atomic(sptep, REMOVED_SPTE);
-                               if (!is_removed_spte(old_spte))
+                               old_spte = kvm_tdp_mmu_write_spte_atomic(sptep, FROZEN_SPTE);
+                               if (!is_frozen_spte(old_spte))
                                        break;
                                cpu_relax();
                        }
@@ -397,11 +397,11 @@ static void handle_removed_pt(struct kvm *kvm, tdp_ptep_t pt, bool shared)
                         * No retry is needed in the atomic update path as the
                         * sole concern is dropping a Dirty bit, i.e. no other
                         * task can zap/remove the SPTE as mmu_lock is held for
-                        * write.  Marking the SPTE as a removed SPTE is not
+                        * write.  Marking the SPTE as a frozen SPTE is not
                         * strictly necessary for the same reason, but using
-                        * the remove SPTE value keeps the shared/exclusive
+                        * the frozen SPTE value keeps the shared/exclusive
                         * paths consistent and allows the handle_changed_spte()
-                        * call below to hardcode the new value to REMOVED_SPTE.
+                        * call below to hardcode the new value to FROZEN_SPTE.
                         *
                         * Note, even though dropping a Dirty bit is the only
                         * scenario where a non-atomic update could result in a
@@ -413,10 +413,10 @@ static void handle_removed_pt(struct kvm *kvm, tdp_ptep_t pt, bool shared)
                         * it here.
                         */
                        old_spte = kvm_tdp_mmu_write_spte(sptep, old_spte,
-                                                         REMOVED_SPTE, level);
+                                                         FROZEN_SPTE, level);
                }
                handle_changed_spte(kvm, kvm_mmu_page_as_id(sp), gfn,
-                                   old_spte, REMOVED_SPTE, level, shared);
+                                   old_spte, FROZEN_SPTE, level, shared);
        }
 
        call_rcu(&sp->rcu_head, tdp_mmu_free_sp_rcu_callback);
@@ -490,19 +490,19 @@ static void handle_changed_spte(struct kvm *kvm, int as_id, gfn_t gfn,
         */
        if (!was_present && !is_present) {
                /*
-                * If this change does not involve a MMIO SPTE or removed SPTE,
+                * If this change does not involve a MMIO SPTE or frozen SPTE,
                 * it is unexpected. Log the change, though it should not
                 * impact the guest since both the former and current SPTEs
                 * are nonpresent.
                 */
                if (WARN_ON_ONCE(!is_mmio_spte(kvm, old_spte) &&
                                 !is_mmio_spte(kvm, new_spte) &&
-                                !is_removed_spte(new_spte)))
+                                !is_frozen_spte(new_spte)))
                        pr_err("Unexpected SPTE change! Nonpresent SPTEs\n"
                               "should not be replaced with another,\n"
                               "different nonpresent SPTE, unless one or both\n"
                               "are MMIO SPTEs, or the new SPTE is\n"
-                              "a temporary removed SPTE.\n"
+                              "a temporary frozen SPTE.\n"
                               "as_id: %d gfn: %llx old_spte: %llx new_spte: %llx level: %d",
                               as_id, gfn, old_spte, new_spte, level);
                return;
@@ -541,7 +541,7 @@ static inline int __must_check __tdp_mmu_set_spte_atomic(struct tdp_iter *iter,
         * and pre-checking before inserting a new SPTE is advantageous as it
         * avoids unnecessary work.
         */
-       WARN_ON_ONCE(iter->yielded || is_removed_spte(iter->old_spte));
+       WARN_ON_ONCE(iter->yielded || is_frozen_spte(iter->old_spte));
 
        /*
         * Note, fast_pf_fix_direct_spte() can also modify TDP MMU SPTEs and
@@ -604,26 +604,26 @@ static inline int __must_check tdp_mmu_zap_spte_atomic(struct kvm *kvm,
         * in its place before the TLBs are flushed.
         *
         * Delay processing of the zapped SPTE until after TLBs are flushed and
-        * the REMOVED_SPTE is replaced (see below).
+        * the FROZEN_SPTE is replaced (see below).
         */
-       ret = __tdp_mmu_set_spte_atomic(iter, REMOVED_SPTE);
+       ret = __tdp_mmu_set_spte_atomic(iter, FROZEN_SPTE);
        if (ret)
                return ret;
 
        kvm_flush_remote_tlbs_gfn(kvm, iter->gfn, iter->level);
 
        /*
-        * No other thread can overwrite the removed SPTE as they must either
+        * No other thread can overwrite the frozen SPTE as they must either
         * wait on the MMU lock or use tdp_mmu_set_spte_atomic() which will not
-        * overwrite the special removed SPTE value. Use the raw write helper to
+        * overwrite the special frozen SPTE value. Use the raw write helper to
         * avoid an unnecessary check on volatile bits.
         */
        __kvm_tdp_mmu_write_spte(iter->sptep, SHADOW_NONPRESENT_VALUE);
 
        /*
         * Process the zapped SPTE after flushing TLBs, and after replacing
-        * REMOVED_SPTE with 0. This minimizes the amount of time vCPUs are
-        * blocked by the REMOVED_SPTE and reduces contention on the child
+        * FROZEN_SPTE with 0. This minimizes the amount of time vCPUs are
+        * blocked by the FROZEN_SPTE and reduces contention on the child
         * SPTEs.
         */
        handle_changed_spte(kvm, iter->as_id, iter->gfn, iter->old_spte,
@@ -653,12 +653,12 @@ static u64 tdp_mmu_set_spte(struct kvm *kvm, int as_id, tdp_ptep_t sptep,
 
        /*
         * No thread should be using this function to set SPTEs to or from the
-        * temporary removed SPTE value.
+        * temporary frozen SPTE value.
         * If operating under the MMU lock in read mode, tdp_mmu_set_spte_atomic
         * should be used. If operating under the MMU lock in write mode, the
-        * use of the removed SPTE should not be necessary.
+        * use of the frozen SPTE should not be necessary.
         */
-       WARN_ON_ONCE(is_removed_spte(old_spte) || is_removed_spte(new_spte));
+       WARN_ON_ONCE(is_frozen_spte(old_spte) || is_frozen_spte(new_spte));
 
        old_spte = kvm_tdp_mmu_write_spte(sptep, old_spte, new_spte, level);
 
@@ -1127,7 +1127,7 @@ int kvm_tdp_mmu_map(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault)
                 * If SPTE has been frozen by another thread, just give up and
                 * retry, avoiding unnecessary page table allocation and free.
                 */
-               if (is_removed_spte(iter.old_spte))
+               if (is_frozen_spte(iter.old_spte))
                        goto retry;
 
                if (iter.level == fault->goal_level)