Re: [PATCH 25/28] KVM: x86/mmu: Require mmu_lock be held for write to zap TDP MMU range

Ben Gardon
2021-11-23T19:58:50Z

On Fri, Nov 19, 2021 at 8:51 PM Sean Christopherson <seanjc@google.com> wrote:
>
> Now that all callers of zap_gfn_range() hold mmu_lock for write, drop
> support for zapping with mmu_lock held for read. That all callers hold
> mmu_lock for write isn't a random coincedence; now that the paths that
> need to zap _everything_ have their own path, the only callers left are
> those that need to zap for functional correctness. And when zapping is
> required for functional correctness, mmu_lock must be held for write,
> otherwise the caller has no guarantees about the state of the TDP MMU
> page tables after it has run, e.g. the SPTE(s) it zapped can be
> immediately replaced by a vCPU faulting in a page.
>
> Signed-off-by: Sean Christopherson <seanjc@google.com>

Reviewed-by: Ben Gardon <bgardon@google.com>

> ---
> arch/x86/kvm/mmu/tdp_mmu.c | 29 ++++++-----------------------
> 1 file changed, 6 insertions(+), 23 deletions(-)
>
> diff --git a/arch/x86/kvm/mmu/tdp_mmu.c b/arch/x86/kvm/mmu/tdp_mmu.c
> index 0e5a0d40e54a..926e92473e92 100644
> --- a/arch/x86/kvm/mmu/tdp_mmu.c
> +++ b/arch/x86/kvm/mmu/tdp_mmu.c
> @@ -844,15 +844,9 @@ bool kvm_tdp_mmu_zap_sp(struct kvm *kvm, struct kvm_mmu_page *sp)
> * function cannot yield, it will not release the MMU lock or reschedule and
> * the caller must ensure it does not supply too large a GFN range, or the
> * operation can cause a soft lockup.
> - *
> - * If shared is true, this thread holds the MMU lock in read mode and must
> - * account for the possibility that other threads are modifying the paging
> - * structures concurrently. If shared is false, this thread should hold the
> - * MMU lock in write mode.
> */
> static bool zap_gfn_range(struct kvm *kvm, struct kvm_mmu_page *root,
> - gfn_t start, gfn_t end, bool can_yield, bool flush,
> - bool shared)
> + gfn_t start, gfn_t end, bool can_yield, bool flush)
> {
> bool zap_all = (start == 0 && end >= tdp_mmu_max_gfn_host());
> struct tdp_iter iter;
> @@ -865,15 +859,14 @@ static bool zap_gfn_range(struct kvm *kvm, struct kvm_mmu_page *root,
>
> end = min(end, tdp_mmu_max_gfn_host());
>
> - kvm_lockdep_assert_mmu_lock_held(kvm, shared);
> + lockdep_assert_held_write(&kvm->mmu_lock);
>
> rcu_read_lock();
>
> for_each_tdp_pte_min_level(iter, root->spt, root->role.level,
> min_level, start, end) {
> -retry:
> if (can_yield &&
> - tdp_mmu_iter_cond_resched(kvm, &iter, flush, shared)) {
> + tdp_mmu_iter_cond_resched(kvm, &iter, flush, false)) {
> flush = false;
> continue;
> }
> @@ -892,17 +885,8 @@ static bool zap_gfn_range(struct kvm *kvm, struct kvm_mmu_page *root,
> !is_last_spte(iter.old_spte, iter.level))
> continue;
>
> - if (!shared) {
> - tdp_mmu_set_spte(kvm, &iter, 0);
> - flush = true;
> - } else if (!tdp_mmu_zap_spte_atomic(kvm, &iter)) {
> - /*
> - * The iter must explicitly re-read the SPTE because
> - * the atomic cmpxchg failed.
> - */
> - iter.old_spte = kvm_tdp_mmu_read_spte(iter.sptep);
> - goto retry;
> - }
> + tdp_mmu_set_spte(kvm, &iter, 0);
> + flush = true;
> }
>
> rcu_read_unlock();
> @@ -921,8 +905,7 @@ bool __kvm_tdp_mmu_zap_gfn_range(struct kvm *kvm, int as_id, gfn_t start,
> struct kvm_mmu_page *root;
>
> for_each_tdp_mmu_root_yield_safe(kvm, root, as_id, false)
> - flush = zap_gfn_range(kvm, root, start, end, can_yield, flush,
> - false);
> + flush = zap_gfn_range(kvm, root, start, end, can_yield, flush);
>
> return flush;
> }
> --
> 2.34.0.rc2.393.gf8c9666880-goog
>