| Message ID | 20240906204515.3276696-3-vipinsh@google.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | KVM: x86/mmu: Run NX huge page recovery under MMU read lock | expand |
Hi Vipin, kernel test robot noticed the following build errors: [auto build test ERROR on 332d2c1d713e232e163386c35a3ba0c1b90df83f] url: https://github.com/intel-lab-lkp/linux/commits/Vipin-Sharma/KVM-x86-mmu-Track-TDP-MMU-NX-huge-pages-separately/20240907-044800 base: 332d2c1d713e232e163386c35a3ba0c1b90df83f patch link: https://lore.kernel.org/r/20240906204515.3276696-3-vipinsh%40google.com patch subject: [PATCH v3 2/2] KVM: x86/mmu: Recover TDP MMU NX huge pages using MMU read lock config: i386-randconfig-005-20240908 (https://download.01.org/0day-ci/archive/20240909/202409090949.xuOxMsJ2-lkp@intel.com/config) compiler: clang version 18.1.5 (https://github.com/llvm/llvm-project 617a15a9eac96088ae5e9134248d8236e34b91b1) reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240909/202409090949.xuOxMsJ2-lkp@intel.com/reproduce) If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags | Reported-by: kernel test robot <lkp@intel.com> | Closes: https://lore.kernel.org/oe-kbuild-all/202409090949.xuOxMsJ2-lkp@intel.com/ All errors (new ones prefixed by >>): >> ld.lld: error: undefined symbol: kvm_tdp_mmu_zap_possible_nx_huge_page >>> referenced by mmu.c:7415 (arch/x86/kvm/mmu/mmu.c:7415) >>> arch/x86/kvm/mmu/mmu.o:(kvm_recover_nx_huge_pages) in archive vmlinux.a
On 2024-09-09 07:29:55, kernel test robot wrote: > Hi Vipin, > > kernel test robot noticed the following build errors: > > [auto build test ERROR on 332d2c1d713e232e163386c35a3ba0c1b90df83f] > > url: https://github.com/intel-lab-lkp/linux/commits/Vipin-Sharma/KVM-x86-mmu-Track-TDP-MMU-NX-huge-pages-separately/20240907-044800 > base: 332d2c1d713e232e163386c35a3ba0c1b90df83f > patch link: https://lore.kernel.org/r/20240906204515.3276696-3-vipinsh%40google.com > patch subject: [PATCH v3 2/2] KVM: x86/mmu: Recover TDP MMU NX huge pages using MMU read lock > config: i386-randconfig-005-20240908 (https://download.01.org/0day-ci/archive/20240909/202409090949.xuOxMsJ2-lkp@intel.com/config) > compiler: clang version 18.1.5 (https://github.com/llvm/llvm-project 617a15a9eac96088ae5e9134248d8236e34b91b1) > reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240909/202409090949.xuOxMsJ2-lkp@intel.com/reproduce) > > If you fix the issue in a separate patch/commit (i.e. not just a new version of > the same patch/commit), kindly add following tags > | Reported-by: kernel test robot <lkp@intel.com> > | Closes: https://lore.kernel.org/oe-kbuild-all/202409090949.xuOxMsJ2-lkp@intel.com/ > > All errors (new ones prefixed by >>): > > >> ld.lld: error: undefined symbol: kvm_tdp_mmu_zap_possible_nx_huge_page > >>> referenced by mmu.c:7415 (arch/x86/kvm/mmu/mmu.c:7415) > >>> arch/x86/kvm/mmu/mmu.o:(kvm_recover_nx_huge_pages) in archive vmlinux.a I missed it because i386 command I used was from config given in v1 of the series by lkp bot. That command was just for build kvm directory and ldd didn't get invoke. I will send out a new version after collecting feedback on this version of the series. I am thinking of below change to fix the error. diff --git a/arch/x86/kvm/mmu/tdp_mmu.h b/arch/x86/kvm/mmu/tdp_mmu.h index ed4bdceb9aec..37620496f64a 100644 --- a/arch/x86/kvm/mmu/tdp_mmu.h +++ b/arch/x86/kvm/mmu/tdp_mmu.h @@ -20,8 +20,6 @@ __must_check static inline bool kvm_tdp_mmu_get_root(struct kvm_mmu_page *root) void kvm_tdp_mmu_put_root(struct kvm *kvm, struct kvm_mmu_page *root); bool kvm_tdp_mmu_zap_leafs(struct kvm *kvm, gfn_t start, gfn_t end, bool flush); -bool kvm_tdp_mmu_zap_possible_nx_huge_page(struct kvm *kvm, - struct kvm_mmu_page *sp); void kvm_tdp_mmu_zap_all(struct kvm *kvm); void kvm_tdp_mmu_invalidate_all_roots(struct kvm *kvm); void kvm_tdp_mmu_zap_invalidated_roots(struct kvm *kvm); @@ -73,8 +71,17 @@ void kvm_tdp_mmu_recover_nx_huge_pages(struct kvm *kvm); #ifdef CONFIG_X86_64 static inline bool is_tdp_mmu_page(struct kvm_mmu_page *sp) { return sp->tdp_mmu_page; } +bool kvm_tdp_mmu_zap_possible_nx_huge_page(struct kvm *kvm, + struct kvm_mmu_page *sp); #else static inline bool is_tdp_mmu_page(struct kvm_mmu_page *sp) { return false; } +static bool kvm_tdp_mmu_zap_possible_nx_huge_page(struct kvm *kvm, + struct kvm_mmu_page *sp) +{ + WARN_ONCE(1, "TDP MMU not supported in 32bit builds"); + return false; +} + #endif #endif /* __KVM_X86_MMU_TDP_MMU_H */ > > -- > 0-DAY CI Kernel Test Service > https://github.com/intel/lkp-tests/wiki
On Fri, Sep 06, 2024, Vipin Sharma wrote: > diff --git a/arch/x86/kvm/mmu/mmu.c b/arch/x86/kvm/mmu/mmu.c > index 455caaaa04f5..fc597f66aa11 100644 > --- a/arch/x86/kvm/mmu/mmu.c > +++ b/arch/x86/kvm/mmu/mmu.c > @@ -7317,8 +7317,8 @@ static int set_nx_huge_pages_recovery_param(const char *val, const struct kernel > return err; > } > > -void kvm_recover_nx_huge_pages(struct kvm *kvm, struct list_head *pages, > - unsigned long nr_pages) > +void kvm_recover_nx_huge_pages(struct kvm *kvm, bool shared, > + struct list_head *pages, unsigned long nr_pages) > { > struct kvm_memory_slot *slot; > int rcu_idx; > @@ -7329,7 +7329,10 @@ void kvm_recover_nx_huge_pages(struct kvm *kvm, struct list_head *pages, > ulong to_zap; > > rcu_idx = srcu_read_lock(&kvm->srcu); > - write_lock(&kvm->mmu_lock); > + if (shared) Hmm, what if we do this? enum kvm_mmu_types { KVM_SHADOW_MMU, #ifdef CONFIG_X86_64 KVM_TDP_MMU, #endif KVM_NR_MMU_TYPES, }; #ifndef CONFIG_X86_64 #define KVM_TDP_MMU -1 #endif And then this becomes: if (mmu_type == KVM_TDP_MMU) > + read_lock(&kvm->mmu_lock); > + else > + write_lock(&kvm->mmu_lock); > > /* > * Zapping TDP MMU shadow pages, including the remote TLB flush, must > @@ -7341,8 +7344,13 @@ void kvm_recover_nx_huge_pages(struct kvm *kvm, struct list_head *pages, > ratio = READ_ONCE(nx_huge_pages_recovery_ratio); > to_zap = ratio ? DIV_ROUND_UP(nr_pages, ratio) : 0; > for ( ; to_zap; --to_zap) { > - if (list_empty(pages)) > + if (tdp_mmu_enabled) Shouldn't this be? if (shared) Or if we do the above if (mmu_type == KVM_TDP_MMU) Actually, better idea (sans comments) if (mmu_type == KVM_TDP_MMU) { read_lock(&kvm->mmu_lock); kvm_tdp_mmu_pages_lock(kvm); } else { write_lock(&kvm->mmu_lock); } rcu_read_lock(); ratio = READ_ONCE(nx_huge_pages_recovery_ratio); to_zap = ratio ? DIV_ROUND_UP(possible_nx->nr_pages, ratio) : 0; for ( ; to_zap; --to_zap) { if (list_empty(possible_nx->pages)) break; ... /* Blah blah blah. */ if (mmu_type == KVM_TDP_MMU) kvm_tdp_mmu_pages_unlock(kvm); ... /* Blah blah blah. */ if (mmu_type == KVM_TDP_MMU) kvm_tdp_mmu_pages_lock(kvm); } kvm_mmu_remote_flush_or_zap(kvm, &invalid_list, flush); rcu_read_unlock(); if (mmu_type == KVM_TDP_MMU) { kvm_tdp_mmu_pages_unlock(kvm); read_unlock(&kvm->mmu_lock); } else { write_unlock(&kvm->mmu_lock); } srcu_read_unlock(&kvm->srcu, rcu_idx); > @@ -825,23 +835,51 @@ static void tdp_mmu_zap_root(struct kvm *kvm, struct kvm_mmu_page *root, > rcu_read_unlock(); > } > > -bool kvm_tdp_mmu_zap_sp(struct kvm *kvm, struct kvm_mmu_page *sp) > +bool kvm_tdp_mmu_zap_possible_nx_huge_page(struct kvm *kvm, This rename, and any refactoring that is associated with said rename, e.g. comments, belongs in a separate patch. > + struct kvm_mmu_page *sp) > { > - u64 old_spte; > + struct tdp_iter iter = { > + .old_spte = sp->ptep ? kvm_tdp_mmu_read_spte(sp->ptep) : 0, > + .sptep = sp->ptep, > + .level = sp->role.level + 1, > + .gfn = sp->gfn, > + .as_id = kvm_mmu_page_as_id(sp), > + }; > + > + lockdep_assert_held_read(&kvm->mmu_lock); Newline here, to isolate the lockdep assertion from the functional code. > + if (WARN_ON_ONCE(!is_tdp_mmu_page(sp))) > + return false; > > /* > - * This helper intentionally doesn't allow zapping a root shadow page, > - * which doesn't have a parent page table and thus no associated entry. > + * Root shadow pages don't a parent page table and thus no associated Missed a word or three. > + * entry, but they can never be possible NX huge pages. > */ > if (WARN_ON_ONCE(!sp->ptep)) > return false; > > - old_spte = kvm_tdp_mmu_read_spte(sp->ptep); > - if (WARN_ON_ONCE(!is_shadow_present_pte(old_spte))) > + /* > + * Since mmu_lock is held in read mode, it's possible another task has > + * already modified the SPTE. Zap the SPTE if and only if the SPTE > + * points at the SP's page table, as checking shadow-present isn't > + * sufficient, e.g. the SPTE could be replaced by a leaf SPTE, or even > + * another SP. Note, spte_to_child_pt() also checks that the SPTE is > + * shadow-present, i.e. guards against zapping a frozen SPTE. > + */ > + if ((tdp_ptep_t)sp->spt != spte_to_child_pt(iter.old_spte, iter.level)) > return false; > > - tdp_mmu_set_spte(kvm, kvm_mmu_page_as_id(sp), sp->ptep, old_spte, > - SHADOW_NONPRESENT_VALUE, sp->gfn, sp->role.level + 1); > + /* > + * If a different task modified the SPTE, then it should be impossible > + * for the SPTE to still be used for the to-be-zapped SP. Non-leaf > + * SPTEs don't have Dirty bits, KVM always sets the Accessed bit when > + * creating non-leaf SPTEs, and all other bits are immutable for non- > + * leaf SPTEs, i.e. the only legal operations for non-leaf SPTEs are > + * zapping and replacement. > + */ > + if (tdp_mmu_set_spte_atomic(kvm, &iter, SHADOW_NONPRESENT_VALUE)) { > + WARN_ON_ONCE((tdp_ptep_t)sp->spt == spte_to_child_pt(iter.old_spte, iter.level)); > + return false; > + } > > return true; > }
diff --git a/arch/x86/kvm/mmu/mmu.c b/arch/x86/kvm/mmu/mmu.c index 455caaaa04f5..fc597f66aa11 100644 --- a/arch/x86/kvm/mmu/mmu.c +++ b/arch/x86/kvm/mmu/mmu.c @@ -7317,8 +7317,8 @@ static int set_nx_huge_pages_recovery_param(const char *val, const struct kernel return err; } -void kvm_recover_nx_huge_pages(struct kvm *kvm, struct list_head *pages, - unsigned long nr_pages) +void kvm_recover_nx_huge_pages(struct kvm *kvm, bool shared, + struct list_head *pages, unsigned long nr_pages) { struct kvm_memory_slot *slot; int rcu_idx; @@ -7329,7 +7329,10 @@ void kvm_recover_nx_huge_pages(struct kvm *kvm, struct list_head *pages, ulong to_zap; rcu_idx = srcu_read_lock(&kvm->srcu); - write_lock(&kvm->mmu_lock); + if (shared) + read_lock(&kvm->mmu_lock); + else + write_lock(&kvm->mmu_lock); /* * Zapping TDP MMU shadow pages, including the remote TLB flush, must @@ -7341,8 +7344,13 @@ void kvm_recover_nx_huge_pages(struct kvm *kvm, struct list_head *pages, ratio = READ_ONCE(nx_huge_pages_recovery_ratio); to_zap = ratio ? DIV_ROUND_UP(nr_pages, ratio) : 0; for ( ; to_zap; --to_zap) { - if (list_empty(pages)) + if (tdp_mmu_enabled) + kvm_tdp_mmu_pages_lock(kvm); + if (list_empty(pages)) { + if (tdp_mmu_enabled) + kvm_tdp_mmu_pages_unlock(kvm); break; + } /* * We use a separate list instead of just using active_mmu_pages @@ -7358,24 +7366,41 @@ void kvm_recover_nx_huge_pages(struct kvm *kvm, struct list_head *pages, WARN_ON_ONCE(!sp->role.direct); /* - * Unaccount and do not attempt to recover any NX Huge Pages - * that are being dirty tracked, as they would just be faulted - * back in as 4KiB pages. The NX Huge Pages in this slot will be - * recovered, along with all the other huge pages in the slot, - * when dirty logging is disabled. + * Unaccount the shadow page before zapping its SPTE so as to + * avoid bouncing tdp_mmu_pages_lock more than is necessary. + * Clearing nx_huge_page_disallowed before zapping is safe, as + * the flag doesn't protect against iTLB multi-hit, it's there + * purely to prevent bouncing the gfn between an NX huge page + * and an X small spage. A vCPU could get stuck tearing down + * the shadow page, e.g. if it happens to fault on the region + * before the SPTE is zapped and replaces the shadow page with + * an NX huge page and get stuck tearing down the child SPTEs, + * but that is a rare race, i.e. shouldn't impact performance. + */ + unaccount_nx_huge_page(kvm, sp); + if (tdp_mmu_enabled) + kvm_tdp_mmu_pages_unlock(kvm); + + /* + * Do not attempt to recover any NX Huge Pages that are being + * dirty tracked, as they would just be faulted back in as 4KiB + * pages. The NX Huge Pages in this slot will be recovered, + * along with all the other huge pages in the slot, when dirty + * logging is disabled. * * Since gfn_to_memslot() is relatively expensive, it helps to * skip it if it the test cannot possibly return true. On the * other hand, if any memslot has logging enabled, chances are - * good that all of them do, in which case unaccount_nx_huge_page() - * is much cheaper than zapping the page. + * good that all of them do, in which case + * unaccount_nx_huge_page() is much cheaper than zapping the + * page. * - * If a memslot update is in progress, reading an incorrect value - * of kvm->nr_memslots_dirty_logging is not a problem: if it is - * becoming zero, gfn_to_memslot() will be done unnecessarily; if - * it is becoming nonzero, the page will be zapped unnecessarily. - * Either way, this only affects efficiency in racy situations, - * and not correctness. + * If a memslot update is in progress, reading an incorrect + * value of kvm->nr_memslots_dirty_logging is not a problem: if + * it is becoming zero, gfn_to_memslot() will be done + * unnecessarily; if it is becoming nonzero, the page will be + * zapped unnecessarily. Either way, this only affects + * efficiency in racy situations, and not correctness. */ slot = NULL; if (atomic_read(&kvm->nr_memslots_dirty_logging)) { @@ -7385,20 +7410,21 @@ void kvm_recover_nx_huge_pages(struct kvm *kvm, struct list_head *pages, slot = __gfn_to_memslot(slots, sp->gfn); WARN_ON_ONCE(!slot); } - - if (slot && kvm_slot_dirty_track_enabled(slot)) - unaccount_nx_huge_page(kvm, sp); - else if (is_tdp_mmu_page(sp)) - flush |= kvm_tdp_mmu_zap_sp(kvm, sp); - else - kvm_mmu_prepare_zap_page(kvm, sp, &invalid_list); + if (!slot || !kvm_slot_dirty_track_enabled(slot)) { + if (shared) + flush |= kvm_tdp_mmu_zap_possible_nx_huge_page(kvm, sp); + else + kvm_mmu_prepare_zap_page(kvm, sp, &invalid_list); + } WARN_ON_ONCE(sp->nx_huge_page_disallowed); if (need_resched() || rwlock_needbreak(&kvm->mmu_lock)) { kvm_mmu_remote_flush_or_zap(kvm, &invalid_list, flush); rcu_read_unlock(); - - cond_resched_rwlock_write(&kvm->mmu_lock); + if (shared) + cond_resched_rwlock_read(&kvm->mmu_lock); + else + cond_resched_rwlock_write(&kvm->mmu_lock); flush = false; rcu_read_lock(); @@ -7408,7 +7434,10 @@ void kvm_recover_nx_huge_pages(struct kvm *kvm, struct list_head *pages, rcu_read_unlock(); - write_unlock(&kvm->mmu_lock); + if (shared) + read_unlock(&kvm->mmu_lock); + else + write_unlock(&kvm->mmu_lock); srcu_read_unlock(&kvm->srcu, rcu_idx); } @@ -7425,7 +7454,7 @@ static long get_nx_huge_page_recovery_timeout(u64 start_time) static void kvm_mmu_recover_nx_huge_pages(struct kvm *kvm) { - kvm_recover_nx_huge_pages(kvm, &kvm->arch.possible_nx_huge_pages, + kvm_recover_nx_huge_pages(kvm, false, &kvm->arch.possible_nx_huge_pages, kvm->arch.nr_possible_nx_huge_pages); } diff --git a/arch/x86/kvm/mmu/mmu_internal.h b/arch/x86/kvm/mmu/mmu_internal.h index 2d2e1231996a..e6b757c59ccc 100644 --- a/arch/x86/kvm/mmu/mmu_internal.h +++ b/arch/x86/kvm/mmu/mmu_internal.h @@ -355,7 +355,7 @@ void track_possible_nx_huge_page(struct kvm *kvm, struct kvm_mmu_page *sp, struct list_head *pages, u64 *nr_pages); void untrack_possible_nx_huge_page(struct kvm *kvm, struct kvm_mmu_page *sp, u64 *nr_pages); -void kvm_recover_nx_huge_pages(struct kvm *kvm, struct list_head *pages, - unsigned long nr_pages); +void kvm_recover_nx_huge_pages(struct kvm *kvm, bool shared, + struct list_head *pages, unsigned long nr_pages); #endif /* __KVM_X86_MMU_INTERNAL_H */ diff --git a/arch/x86/kvm/mmu/tdp_mmu.c b/arch/x86/kvm/mmu/tdp_mmu.c index 9a6c26d20210..8a6ffc150c99 100644 --- a/arch/x86/kvm/mmu/tdp_mmu.c +++ b/arch/x86/kvm/mmu/tdp_mmu.c @@ -74,9 +74,19 @@ static void tdp_mmu_free_sp_rcu_callback(struct rcu_head *head) tdp_mmu_free_sp(sp); } +void kvm_tdp_mmu_pages_lock(struct kvm *kvm) +{ + spin_lock(&kvm->arch.tdp_mmu_pages_lock); +} + +void kvm_tdp_mmu_pages_unlock(struct kvm *kvm) +{ + spin_unlock(&kvm->arch.tdp_mmu_pages_lock); +} + void kvm_tdp_mmu_recover_nx_huge_pages(struct kvm *kvm) { - kvm_recover_nx_huge_pages(kvm, + kvm_recover_nx_huge_pages(kvm, true, &kvm->arch.tdp_mmu_possible_nx_huge_pages, kvm->arch.tdp_mmu_nr_possible_nx_huge_pages); } @@ -825,23 +835,51 @@ static void tdp_mmu_zap_root(struct kvm *kvm, struct kvm_mmu_page *root, rcu_read_unlock(); } -bool kvm_tdp_mmu_zap_sp(struct kvm *kvm, struct kvm_mmu_page *sp) +bool kvm_tdp_mmu_zap_possible_nx_huge_page(struct kvm *kvm, + struct kvm_mmu_page *sp) { - u64 old_spte; + struct tdp_iter iter = { + .old_spte = sp->ptep ? kvm_tdp_mmu_read_spte(sp->ptep) : 0, + .sptep = sp->ptep, + .level = sp->role.level + 1, + .gfn = sp->gfn, + .as_id = kvm_mmu_page_as_id(sp), + }; + + lockdep_assert_held_read(&kvm->mmu_lock); + if (WARN_ON_ONCE(!is_tdp_mmu_page(sp))) + return false; /* - * This helper intentionally doesn't allow zapping a root shadow page, - * which doesn't have a parent page table and thus no associated entry. + * Root shadow pages don't a parent page table and thus no associated + * entry, but they can never be possible NX huge pages. */ if (WARN_ON_ONCE(!sp->ptep)) return false; - old_spte = kvm_tdp_mmu_read_spte(sp->ptep); - if (WARN_ON_ONCE(!is_shadow_present_pte(old_spte))) + /* + * Since mmu_lock is held in read mode, it's possible another task has + * already modified the SPTE. Zap the SPTE if and only if the SPTE + * points at the SP's page table, as checking shadow-present isn't + * sufficient, e.g. the SPTE could be replaced by a leaf SPTE, or even + * another SP. Note, spte_to_child_pt() also checks that the SPTE is + * shadow-present, i.e. guards against zapping a frozen SPTE. + */ + if ((tdp_ptep_t)sp->spt != spte_to_child_pt(iter.old_spte, iter.level)) return false; - tdp_mmu_set_spte(kvm, kvm_mmu_page_as_id(sp), sp->ptep, old_spte, - SHADOW_NONPRESENT_VALUE, sp->gfn, sp->role.level + 1); + /* + * If a different task modified the SPTE, then it should be impossible + * for the SPTE to still be used for the to-be-zapped SP. Non-leaf + * SPTEs don't have Dirty bits, KVM always sets the Accessed bit when + * creating non-leaf SPTEs, and all other bits are immutable for non- + * leaf SPTEs, i.e. the only legal operations for non-leaf SPTEs are + * zapping and replacement. + */ + if (tdp_mmu_set_spte_atomic(kvm, &iter, SHADOW_NONPRESENT_VALUE)) { + WARN_ON_ONCE((tdp_ptep_t)sp->spt == spte_to_child_pt(iter.old_spte, iter.level)); + return false; + } return true; } diff --git a/arch/x86/kvm/mmu/tdp_mmu.h b/arch/x86/kvm/mmu/tdp_mmu.h index 510baf3eb3f1..ed4bdceb9aec 100644 --- a/arch/x86/kvm/mmu/tdp_mmu.h +++ b/arch/x86/kvm/mmu/tdp_mmu.h @@ -20,7 +20,8 @@ __must_check static inline bool kvm_tdp_mmu_get_root(struct kvm_mmu_page *root) void kvm_tdp_mmu_put_root(struct kvm *kvm, struct kvm_mmu_page *root); bool kvm_tdp_mmu_zap_leafs(struct kvm *kvm, gfn_t start, gfn_t end, bool flush); -bool kvm_tdp_mmu_zap_sp(struct kvm *kvm, struct kvm_mmu_page *sp); +bool kvm_tdp_mmu_zap_possible_nx_huge_page(struct kvm *kvm, + struct kvm_mmu_page *sp); void kvm_tdp_mmu_zap_all(struct kvm *kvm); void kvm_tdp_mmu_invalidate_all_roots(struct kvm *kvm); void kvm_tdp_mmu_zap_invalidated_roots(struct kvm *kvm); @@ -66,6 +67,8 @@ int kvm_tdp_mmu_get_walk(struct kvm_vcpu *vcpu, u64 addr, u64 *sptes, int *root_level); u64 *kvm_tdp_mmu_fast_pf_get_last_sptep(struct kvm_vcpu *vcpu, gfn_t gfn, u64 *spte); +void kvm_tdp_mmu_pages_lock(struct kvm *kvm); +void kvm_tdp_mmu_pages_unlock(struct kvm *kvm); void kvm_tdp_mmu_recover_nx_huge_pages(struct kvm *kvm); #ifdef CONFIG_X86_64
Use MMU read lock to recover TDP MMU NX huge pages. Iterate huge pages list under tdp_mmu_pages_lock protection and unaccount the page before dropping the lock. Modify kvm_tdp_mmu_zap_sp() to kvm_tdp_mmu_zap_possible_nx_huge_page() as there are no other user of it. Ignore the zap if any of the following condition is true: - It is a root page. - Parent is pointing to: - A different page table. - A huge page. - Not present Warn if zapping SPTE fails and current SPTE is still pointing to same page table. This should never happen. There is always a race between dirty logging, vCPU faults, and NX huge page recovery for backing a gfn by an NX huge page or an execute small page. Unaccounting sooner during the list traversal is increasing the window of that race. Functionally, it is okay, because accounting doesn't protect against iTLB multi-hit bug, it is there purely to prevent KVM from bouncing a gfn between two page sizes. The only downside is that a vCPU will end up doing more work in tearing down all the child SPTEs. This should be a very rare race. Zapping under MMU read lock unblock vCPUs which are waiting for MMU read lock. This optimizaion is done to solve a guest jitter issue on Windows VM which was observing an increase in network latency. The test workload sets up two Windows VM and use latte.exe[1] binary to run network latency benchmark. Running NX huge page recovery under MMU lock was causing latency to increase up to 30 ms because vCPUs were waiting for MMU lock. Running the tool on VMs using MMU read lock NX huge page recovery removed the jitter issue completely and MMU lock wait time by vCPUs was also reduced. Command used for testing: Server: latte.exe -udp -a 192.168.100.1:9000 -i 10000000 Client: latte.exe -c -udp -a 192.168.100.1:9000 -i 10000000 -hist -hl 1000 -hc 30 Output from the latency tool on client: Before ------ Protocol UDP SendMethod Blocking ReceiveMethod Blocking SO_SNDBUF Default SO_RCVBUF Default MsgSize(byte) 4 Iterations 10000000 Latency(usec) 69.98 CPU(%) 2.8 CtxSwitch/sec 32783 (2.29/iteration) SysCall/sec 99948 (6.99/iteration) Interrupt/sec 55164 (3.86/iteration) Interval(usec) Frequency 0 9999967 1000 14 2000 0 3000 5 4000 1 5000 0 6000 0 7000 0 8000 0 9000 0 10000 0 11000 0 12000 2 13000 2 14000 4 15000 2 16000 2 17000 0 18000 1 After ----- Protocol UDP SendMethod Blocking ReceiveMethod Blocking SO_SNDBUF Default SO_RCVBUF Default MsgSize(byte) 4 Iterations 10000000 Latency(usec) 67.66 CPU(%) 1.6 CtxSwitch/sec 32869 (2.22/iteration) SysCall/sec 69366 (4.69/iteration) Interrupt/sec 50693 (3.43/iteration) Interval(usec) Frequency 0 9999972 1000 27 2000 1 [1] https://github.com/microsoft/latte Suggested-by: Sean Christopherson <seanjc@google.com> Signed-off-by: Vipin Sharma <vipinsh@google.com> --- arch/x86/kvm/mmu/mmu.c | 85 ++++++++++++++++++++++----------- arch/x86/kvm/mmu/mmu_internal.h | 4 +- arch/x86/kvm/mmu/tdp_mmu.c | 56 ++++++++++++++++++---- arch/x86/kvm/mmu/tdp_mmu.h | 5 +- 4 files changed, 110 insertions(+), 40 deletions(-)