lkml.org 
[lkml]   [2023]   [Feb]   [10]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    Subject[Patch v3 1/7] KVM: x86/mmu: Add a helper function to check if an SPTE needs atomic write
    From
    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>
    ---
    arch/x86/kvm/mmu/tdp_iter.h | 34 ++++++++++++++++++++--------------
    1 file changed, 20 insertions(+), 14 deletions(-)

    diff --git a/arch/x86/kvm/mmu/tdp_iter.h b/arch/x86/kvm/mmu/tdp_iter.h
    index f0af385c56e0..c11c5d00b2c1 100644
    --- 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);
    --
    2.39.1.581.gbfd45094c4-goog
    \
     
     \ /
      Last update: 2023-03-27 00:18    [W:3.785 / U:0.292 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site