KVM: allow mapping non-refcounted pages
v8 cover KVM: allow mapping non-refcounted pages
From: David Stevens <[email protected]>
This patch series adds support for mapping VM_IO and VM_PFNMAP memory that is backed by struct pages that aren't currently being refcounted (e.g. tail pages of non-compound higher order allocations) into the guest.
Our use case is virtio-gpu blob resources [1], which directly map host graphics buffers into the guest as "vram" for the virtio-gpu device. This feature currently does not work on systems using the amdgpu driver, as that driver allocates non-compound higher order pages via ttm_pool_alloc_page.
First, this series replaces the __gfn_to_pfn_memslot API with a more extensible __kvm_faultin_pfn API. The updated API rearranges __gfn_to_pfn_memslot's args into a struct and where possible packs the bool arguments into a FOLL_ flags argument. The refactoring changes do not change any behavior, except as noted in the PPC change.
When introduced in the refactoring, __kvm_faultin_pfn implies FOLL_GET to preserve existing behavior. From there, the API is made to support mapping non-refcounted pages by respecting the FOLL_GET flag.
This series only adds support for non-refcounted pages to the x86 MMU. Other MMUs can likely be updated without too much difficulty, but it is not needed at this point. Updating other parts of KVM (e.g. pfncache) is not straightforward [2].
[1]
https://patchwork.kernel.org/project/dri-devel/cover/[email protected]/
[2] https://lore.kernel.org/all/[email protected]/
v7 -> v8:
- Set access bits before releasing mmu_lock.
- Pass FOLL_GET on 32-bit x86 or !tdp_enabled.
- Refactor FOLL_GET handling, add kvm_follow_refcounted_pfn helper.
- Set refcounted bit on >4k pages.
- Add comments and apply formatting suggestions.
- rebase on kvm next branch.
v6 -> v7:
- Replace __gfn_to_pfn_memslot with a more flexible __kvm_faultin_pfn, and extend that API to support non-refcounted pages.
v5 -> v6:
- rebase on kvm next branch
- rename gfn_to_pfn_page to gfn_to_pfn_noref
- fix uninitialized outparam in error case of __kvm_faultin_pfn
- add kvm_release_pfn_noref_clean for releasing pfn/page pair
v4 -> v5:
- rebase on kvm next branch again
v3 -> v4:
- rebase on kvm next branch again
- Add some more context to a comment in ensure_pfn_ref
v2 -> v3:
- rebase on kvm next branch
v1 -> v2:
- Introduce new gfn_to_pfn_page functions instead of modifying the behavior of existing gfn_to_pfn functions, to make the change less invasive.
- Drop changes to mmu_audit.c
- Include Nicholas Piggin's patch to avoid corrupting refcount in the follow_pte case, and use it in depreciated gfn_to_pfn functions.
- Rebase on kvm/next
David Stevens (7):
KVM: mmu: Introduce __kvm_follow_pfn function
KVM: mmu: Make __kvm_follow_pfn not imply FOLL_GET
KVM: x86/mmu: Migrate to __kvm_follow_pfn
KVM: x86/mmu: Don't pass FOLL_GET to __kvm_follow_pfn
KVM: arm64: Migrate to __kvm_follow_pfn
KVM: PPC: Migrate to __kvm_follow_pfn
KVM: mmu: remove __gfn_to_pfn_memslot
Sean Christopherson (1):
KVM: Assert that a page's refcount is elevated when marking
accessed/dirty
arch/arm64/kvm/mmu.c | 25 +-- arch/powerpc/include/asm/kvm_book3s.h | 2 +- arch/powerpc/kvm/book3s_64_mmu_hv.c | 38 ++-- arch/powerpc/kvm/book3s_64_mmu_radix.c | 50 +++--- arch/powerpc/kvm/book3s_hv_nested.c | 4 +- arch/x86/kvm/mmu/mmu.c | 94 +++++++--- arch/x86/kvm/mmu/mmu_internal.h | 1 + arch/x86/kvm/mmu/paging_tmpl.h | 8 +- arch/x86/kvm/mmu/spte.c | 4 +- arch/x86/kvm/mmu/spte.h | 12 +- arch/x86/kvm/mmu/tdp_mmu.c | 22 ++- include/linux/kvm_host.h | 26 +++ virt/kvm/kvm_main.c | 231 ++++++++++++++----------- virt/kvm/kvm_mm.h | 3 +- virt/kvm/pfncache.c | 10 +- 15 files changed, 316 insertions(+), 214 deletions(-)
Signature · 1 line
2.42.0.rc1.204.g551eb34607-goog
PATCH v8 1/8 KVM: Assert that a page's refcount is elevated when marking accessed/dirty
From: Sean Christopherson <[email protected]>
Assert that a page's refcount is elevated, i.e. that _something_ holds a reference to the page, when KVM marks a page as accessed and/or dirty. KVM typically doesn't hold a reference to pages that are mapped into the guest, e.g. to allow page migration, compaction, swap, etc., and instead relies on mmu_notifiers to react to changes in the primary MMU.
Incorrect handling of mmu_notifier events (or similar mechanisms) can result in KVM keeping a mapping beyond the lifetime of the backing page, i.e. can (and often does) result in use-after-free. Yelling if KVM marks a freed page as accessed/dirty doesn't prevent badness as KVM usually only does A/D updates when unmapping memory from the guest, i.e. the assertion fires well after an underlying bug has occurred, but yelling does help detect, triage, and debug use-after-free bugs.
Note, the assertion must use page_count(), NOT page_ref_count()! For hugepages, the returned struct page may be a tailpage and thus not have its own refcount.
--- virt/kvm/kvm_main.c | 13 +++++++++++++ 1 file changed, 13 insertions(+)
virt/kvm/kvm_main.c +13 -0
@@ -2888,6 +2888,19 @@ EXPORT_SYMBOL_GPL(kvm_vcpu_unmap);static bool kvm_is_ad_tracked_page (struct page *page) { +/* +* Assert that KVM isn't attempting to mark a freed page as Accessed or +* Dirty, i.e. that KVM's MMU doesn't have a use-after-free bug. KVM +* (typically) doesn't pin pages that are mapped in KVM's MMU, and +* instead relies on mmu_notifiers to know when a mapping needs to be +* zapped/invalidated. Unmapping from KVM's MMU must happen _before_ +* KVM returns from its mmu_notifier, i.e. the page should have an +* elevated refcount at this point even though KVM doesn't hold a +* reference of its own. +*/ +if (WARN_ON_ONCE (!page_count (page))) +return false; +/* * Per page-flags.h, pages tagged PG_reserved "should in general not be * touched (e.g. set dirty) except by its owner".
Signature · 1 line
2.42.0.rc1.204.g551eb34607-goog
PATCH v8 2/8 KVM: mmu: Introduce __kvm_follow_pfn function
In reply to David StevensFrom: David Stevens <[email protected]>
Introduce __kvm_follow_pfn, which will replace __gfn_to_pfn_memslot. __kvm_follow_pfn refactors the old API's arguments into a struct and, where possible, combines the boolean arguments into a single flags argument.
--- include/linux/kvm_host.h | 16 ++++ virt/kvm/kvm_main.c | 171 ++++++++++++++++++++++----------------- virt/kvm/kvm_mm.h | 3 +- virt/kvm/pfncache.c | 10 ++- 4 files changed, 123 insertions(+), 77 deletions(-)
include/linux/kvm_host.h +16 -0
@@ -97,6 +97,7 @@#define KVM_PFN_ERR_HWPOISON (KVM_PFN_ERR_MASK + 1)#define KVM_PFN_ERR_RO_FAULT (KVM_PFN_ERR_MASK + 2)#define KVM_PFN_ERR_SIGPENDING (KVM_PFN_ERR_MASK + 3) +#define KVM_PFN_ERR_NEEDS_IO (KVM_PFN_ERR_MASK + 4)/* * error pfns indicate that the gfn is in slot but faild to
@@ -1156,6 +1157,21 @@ unsigned long gfn_to_hva_memslot_prot(struct kvm_memory_slot *slot, gfn_t gfn,void kvm_release_page_clean (struct page *page);void kvm_release_page_dirty (struct page *page); +struct kvm_follow_pfn { +const struct kvm_memory_slot *slot; +gfn_t gfn; +unsigned int flags; +bool atomic; +/* Try to create a writable mapping even for a read fault */ +bool try_map_writable; + +/* Outputs of __kvm_follow_pfn */ +hva_t hva; +bool writable; +}; + +kvm_pfn_t __kvm_follow_pfn (struct kvm_follow_pfn *foll); +kvm_pfn_t gfn_to_pfn (struct kvm *kvm,gfn_t gfn);kvm_pfn_t gfn_to_pfn_prot (struct kvm *kvm,gfn_t gfn,bool write_fault,bool *writable);
virt/kvm/kvm_main.c +98 -73
300 lines not on this page · raw message
virt/kvm/kvm_mm.h +1 -2
@@ -20,8 +20,7 @@#define KVM_MMU_UNLOCK (kvm) spin_unlock(&(kvm)->mmu_lock)#endif /* KVM_HAVE_MMU_RWLOCK */ -kvm_pfn_t hva_to_pfn (unsigned long addr,bool atomic,bool interruptible, -bool *async,bool write_fault,bool *writable); +kvm_pfn_t hva_to_pfn (struct kvm_follow_pfn *foll);#ifdef CONFIG_HAVE_KVM_PFNCACHE void gfn_to_pfn_cache_invalidate_start(struct kvm *kvm,
virt/kvm/pfncache.c +8 -2
@@ -144,6 +144,12 @@ static kvm_pfn_t hva_to_pfn_retry(struct gfn_to_pfn_cache *gpc)kvm_pfn_t new_pfn =KVM_PFN_ERR_FAULT ;void *new_khva =NULL ;unsigned long mmu_seq; +struct kvm_follow_pfn foll = { + .slot = gpc->memslot, + .gfn =gpa_to_gfn (gpc->gpa), + .flags =FOLL_WRITE , + .hva = gpc->uhva, + };lockdep_assert_held (&gpc->refresh_lock);
@@ -182,8 +188,8 @@ static kvm_pfn_t hva_to_pfn_retry(struct gfn_to_pfn_cache *gpc)cond_resched (); } -/* We always request a writeable mapping */ - new_pfn =hva_to_pfn (gpc->uhva, false, false,NULL , true,NULL ); +/* We always request a writable mapping */ + new_pfn =hva_to_pfn (&foll);if (is_error_noslot_pfn (new_pfn)) goto out_error;
Signature · 1 line
2.42.0.rc1.204.g551eb34607-goog
PATCH v8 3/8 KVM: mmu: Make __kvm_follow_pfn not imply FOLL_GET
In reply to David StevensFrom: David Stevens <[email protected]>
Make it so that __kvm_follow_pfn does not imply FOLL_GET. This allows callers to resolve a gfn when the associated pfn has a valid struct page that isn't being actively refcounted (e.g. tail pages of non-compound higher order pages). For a caller to safely omit FOLL_GET, all usages of the returned pfn must be guarded by a mmu notifier.
This also adds a is_refcounted_page out parameter to kvm_follow_pfn that is set when the returned pfn has an associated struct page with a valid refcount. Callers that don't pass FOLL_GET should remember this value and use it to avoid places like kvm_is_ad_tracked_page that assume a non-zero refcount.
--- include/linux/kvm_host.h | 7 ++++ virt/kvm/kvm_main.c | 84 ++++++++++++++++++++++++---------------- virt/kvm/pfncache.c | 2 +- 3 files changed, 58 insertions(+), 35 deletions(-)
include/linux/kvm_host.h +7 -0
@@ -1164,10 +1164,17 @@ struct kvm_follow_pfn {bool atomic;/* Try to create a writable mapping even for a read fault */ bool try_map_writable; +/* +* Usage of the returned pfn will be guared by a mmu notifier. Must +* be true if FOLL_GET is not set. +*/ +bool guarded_by_mmu_notifier;/* Outputs of __kvm_follow_pfn */ hva_t hva;bool writable; +/* True if the returned pfn is for a page with a valid refcount. */ +bool is_refcounted_page; };kvm_pfn_t __kvm_follow_pfn (struct kvm_follow_pfn *foll);
virt/kvm/kvm_main.c +50 -34
162 lines not on this page · raw message
virt/kvm/pfncache.c +1 -1
@@ -147,7 +147,7 @@ static kvm_pfn_t hva_to_pfn_retry(struct gfn_to_pfn_cache *gpc)struct kvm_follow_pfn foll = { .slot = gpc->memslot, .gfn =gpa_to_gfn (gpc->gpa), - .flags =FOLL_WRITE , + .flags =FOLL_WRITE |FOLL_GET , .hva = gpc->uhva, };
Signature · 1 line
2.42.0.rc1.204.g551eb34607-goog
PATCH v8 4/8 KVM: x86/mmu: Migrate to __kvm_follow_pfn
In reply to David StevensFrom: David Stevens <[email protected]>
Migrate from __gfn_to_pfn_memslot to __kvm_follow_pfn. Most arguments directly map to the new API. The largest change is replacing the async in/out parameter with FOLL_NOWAIT parameter and the KVM_PFN_ERR_NEEDS_IO return value.
--- arch/x86/kvm/mmu/mmu.c | 41 +++++++++++++++++++++++++++++++---------- 1 file changed, 31 insertions(+), 10 deletions(-)
arch/x86/kvm/mmu/mmu.c +31 -10
@@ -4296,7 +4296,12 @@ void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu, struct kvm_async_pf *work)static int __kvm_faultin_pfn (struct kvm_vcpu *vcpu,struct kvm_page_fault *fault) {struct kvm_memory_slot *slot = fault->slot; -bool async; +struct kvm_follow_pfn foll = { + .slot = slot, + .gfn = fault->gfn, + .flags =FOLL_GET | (fault->write ?FOLL_WRITE :0 ), + .try_map_writable = true, + };/* * Retry the page fault if the gfn hit a memslot that is being deleted
@@ -4325,12 +4330,20 @@ static int __kvm_faultin_pfn(struct kvm_vcpu *vcpu, struct kvm_page_fault *faultreturn RET_PF_EMULATE ; } - async = false; - fault->pfn =__gfn_to_pfn_memslot (slot, fault->gfn, false, false, &async, - fault->write, &fault->map_writable, - &fault->hva); -if (!async) -return RET_PF_CONTINUE ;/* *pfn has correct page already */ + foll.flags |=FOLL_NOWAIT ; + fault->pfn =__kvm_follow_pfn (&foll); + +if (!is_error_noslot_pfn (fault->pfn)) + goto success; + +/* +* If __kvm_follow_pfn() failed because I/O is needed to fault in the +* page, then either set up an asynchronous #PF to do the I/O, or if +* doing an async #PF isn't possible, retry __kvm_follow_pfn() with +* I/O allowed. All other failures are fatal, i.e. retrying won't help. +*/ +if (fault->pfn !=KVM_PFN_ERR_NEEDS_IO ) +return RET_PF_CONTINUE ;if (!fault->prefetch &&kvm_can_do_async_pf (vcpu)) {trace_kvm_try_async_get_page (fault->addr, fault->gfn);
@@ -4348,9 +4361,17 @@ static int __kvm_faultin_pfn(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault* to wait for IO. Note, gup always bails if it is unable to quickly * get a page and a fatal signal, i.e. SIGKILL, is pending. */ - fault->pfn =__gfn_to_pfn_memslot (slot, fault->gfn, false, true,NULL , - fault->write, &fault->map_writable, - &fault->hva); + foll.flags |=FOLL_INTERRUPTIBLE ; + foll.flags &= ~FOLL_NOWAIT ; + fault->pfn =__kvm_follow_pfn (&foll); + +if (!is_error_noslot_pfn (fault->pfn)) + goto success; + +return RET_PF_CONTINUE ; +success: + fault->hva = foll.hva; + fault->map_writable = foll.writable;return RET_PF_CONTINUE ; }
Signature · 1 line
2.42.0.rc1.204.g551eb34607-goog
PATCH v8 5/8 KVM: x86/mmu: Don't pass FOLL_GET to __kvm_follow_pfn
In reply to David StevensFrom: David Stevens <[email protected]>
Stop passing FOLL_GET to __kvm_follow_pfn. This allows the host to map memory into the guest that is backed by un-refcounted struct pages - for example, the tail pages of higher order non-compound pages allocated by the amdgpu driver via ttm_pool_alloc_page.
The bulk of this change is tracking the is_refcounted_page flag so that non-refcounted pages don't trigger page_count() == 0 warnings. This is done by storing the flag in an unused bit in the sptes. This only bit is not available in PAE SPTEs, so FOLL_GET is only omitted for TDP on x86-64.
--- arch/x86/kvm/mmu/mmu.c | 55 +++++++++++++++++++++++---------- arch/x86/kvm/mmu/mmu_internal.h | 1 + arch/x86/kvm/mmu/paging_tmpl.h | 8 +++-- arch/x86/kvm/mmu/spte.c | 4 ++- arch/x86/kvm/mmu/spte.h | 12 ++++++- arch/x86/kvm/mmu/tdp_mmu.c | 22 +++++++------ include/linux/kvm_host.h | 3 ++ virt/kvm/kvm_main.c | 6 ++-- 8 files changed, 79 insertions(+), 32 deletions(-)
arch/x86/kvm/mmu/mmu.c +39 -16
@@ -553,12 +553,14 @@ static bool mmu_spte_update(u64 *sptep, u64 new_spte)if (is_accessed_spte (old_spte) && !is_accessed_spte (new_spte)) { flush = true; -kvm_set_pfn_accessed (spte_to_pfn (old_spte)); +if (is_refcounted_page_pte (old_spte)) +kvm_set_page_accessed (pfn_to_page (spte_to_pfn (old_spte))); }if (is_dirty_spte (old_spte) && !is_dirty_spte (new_spte)) { flush = true; -kvm_set_pfn_dirty (spte_to_pfn (old_spte)); +if (is_refcounted_page_pte (old_spte)) +kvm_set_page_dirty (pfn_to_page (spte_to_pfn (old_spte))); }return flush;
@@ -596,14 +598,18 @@ static u64 mmu_spte_clear_track_bits(struct kvm *kvm, u64 *sptep)* before they are reclaimed. Sanity check that, if the pfn is backed * by a refcounted page, the refcount is elevated. */ - page =kvm_pfn_to_refcounted_page (pfn); -WARN_ON (page && !page_count (page)); +if (is_refcounted_page_pte (old_spte)) { + page =kvm_pfn_to_refcounted_page (pfn); +WARN_ON (!page || !page_count (page)); + } -if (is_accessed_spte (old_spte)) -kvm_set_pfn_accessed (pfn); +if (is_refcounted_page_pte (old_spte)) { +if (is_accessed_spte (old_spte)) +kvm_set_page_accessed (pfn_to_page (pfn)); -if (is_dirty_spte (old_spte)) -kvm_set_pfn_dirty (pfn); +if (is_dirty_spte (old_spte)) +kvm_set_page_dirty (pfn_to_page (pfn)); + }return old_spte; }
@@ -639,8 +645,8 @@ static bool mmu_spte_age(u64 *sptep)* Capture the dirty status of the page, so that it doesn't get * lost when the SPTE is marked for access tracking. */ -if (is_writable_pte (spte)) -kvm_set_pfn_dirty (spte_to_pfn (spte)); +if (is_writable_pte (spte) &&is_refcounted_page_pte (spte)) +kvm_set_page_dirty (pfn_to_page (spte_to_pfn (spte))); spte =mark_spte_for_access_track (spte);mmu_spte_update_no_track (sptep, spte);
@@ -1278,8 +1284,8 @@ static bool spte_wrprot_for_clear_dirty(u64 *sptep) {bool was_writable =test_and_clear_bit (PT_WRITABLE_SHIFT , (unsigned long *)sptep); -if (was_writable && !spte_ad_enabled (*sptep)) -kvm_set_pfn_dirty (spte_to_pfn (*sptep)); +if (was_writable && !spte_ad_enabled (*sptep) &&is_refcounted_page_pte (*sptep)) +kvm_set_page_dirty (pfn_to_page (spte_to_pfn (*sptep)));return was_writable; }
@@ -2937,6 +2943,11 @@ static int mmu_set_spte(struct kvm_vcpu *vcpu, struct kvm_memory_slot *slot,bool host_writable = !fault || fault->map_writable;bool prefetch = !fault || fault->prefetch;bool write_fault = fault && fault->write; +/* +* Prefetching uses gfn_to_page_many_atomic, which never gets +* non-refcounted pages. +*/ +bool is_refcounted = !fault || fault->is_refcounted_page;pgprintk ("%s: spte %llx write_fault %d gfn %llx\n" , __func__, *sptep, write_fault, gfn);
@@ -2969,7 +2980,7 @@ static int mmu_set_spte(struct kvm_vcpu *vcpu, struct kvm_memory_slot *slot, } wrprot =make_spte (vcpu, sp, slot, pte_access, gfn, pfn, *sptep, prefetch, - true, host_writable, &spte); + true, host_writable, is_refcounted, &spte);if (*sptep == spte) { ret =RET_PF_SPURIOUS ;
@@ -4296,11 +4307,19 @@ void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu, struct kvm_async_pf *work)static int __kvm_faultin_pfn (struct kvm_vcpu *vcpu,struct kvm_page_fault *fault) {struct kvm_memory_slot *slot = fault->slot; +/* +* We only allow non-refcounted pages if we can track whether or not +* pages are refcounted via an SPTE bit. This bit is not available +* in PAE SPTEs, so pass FOLL_GET if we may have to deal with those. +*/ +unsigned int get_flag = (tdp_enabled &&IS_ENABLED (CONFIG_X86_64 )) ? +0 :FOLL_GET ;struct kvm_follow_pfn foll = { .slot = slot, .gfn = fault->gfn, - .flags =FOLL_GET | (fault->write ?FOLL_WRITE :0 ), + .flags = (fault->write ?FOLL_WRITE :0 ) | get_flag, .try_map_writable = true, + .guarded_by_mmu_notifier = true, };/*
@@ -4317,6 +4336,7 @@ static int __kvm_faultin_pfn(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault fault->slot =NULL ; fault->pfn =KVM_PFN_NOSLOT ; fault->map_writable = false; + fault->is_refcounted_page = false;return RET_PF_CONTINUE ; }/*
@@ -4372,6 +4392,7 @@ static int __kvm_faultin_pfn(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault success: fault->hva = foll.hva; fault->map_writable = foll.writable; + fault->is_refcounted_page = foll.is_refcounted_page;return RET_PF_CONTINUE ; }
@@ -4456,8 +4477,9 @@ static int direct_page_fault(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault r =direct_map (vcpu, fault); out_unlock: +if (fault->is_refcounted_page) +kvm_set_page_accessed (pfn_to_page (fault->pfn));write_unlock (&vcpu->kvm->mmu_lock); -kvm_release_pfn_clean (fault->pfn);return r; }
@@ -4534,8 +4556,9 @@ static int kvm_tdp_mmu_page_fault(struct kvm_vcpu *vcpu, r =kvm_tdp_mmu_map (vcpu, fault); out_unlock: +if (fault->is_refcounted_page) +kvm_set_page_accessed (pfn_to_page (fault->pfn));read_unlock (&vcpu->kvm->mmu_lock); -kvm_release_pfn_clean (fault->pfn); return r; }#endif
arch/x86/kvm/mmu/mmu_internal.h +1 -0
@@ -240,6 +240,7 @@ struct kvm_page_fault {kvm_pfn_t pfn;hva_t hva;bool map_writable; +bool is_refcounted_page;/* * Indicates the guest is trying to write a gfn that contains one or
arch/x86/kvm/mmu/paging_tmpl.h +5 -3
@@ -828,8 +828,9 @@ static int FNAME(page_fault)(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault r =FNAME (fetch)(vcpu, fault, &walker); out_unlock: +if (fault->is_refcounted_page) +kvm_set_page_accessed (pfn_to_page (fault->pfn));write_unlock (&vcpu->kvm->mmu_lock); -kvm_release_pfn_clean (fault->pfn);return r; }
@@ -883,7 +884,7 @@ static gpa_t FNAME(gva_to_gpa)(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu,*/ static int FNAME (sync_spte )(struct kvm_vcpu *vcpu,struct kvm_mmu_page *sp,int i) { -bool host_writable; +bool host_writable, is_refcounted;gpa_t first_pte_gpa;u64 *sptep, spte;struct kvm_memory_slot *slot;
@@ -940,10 +941,11 @@ static int FNAME(sync_spte)(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp, int sptep = &sp->spt[i]; spte = *sptep; host_writable = spte & shadow_host_writable_mask; + is_refcounted = spte &SPTE_MMU_PAGE_REFCOUNTED ; slot =kvm_vcpu_gfn_to_memslot (vcpu, gfn);make_spte (vcpu, sp, slot, pte_access, gfn,spte_to_pfn (spte), spte, true, false, - host_writable, &spte); + host_writable, is_refcounted, &spte);return mmu_spte_update (sptep, spte); }
arch/x86/kvm/mmu/spte.c +3 -1
@@ -138,7 +138,7 @@ bool make_spte(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp,const struct kvm_memory_slot *slot, unsigned int pte_access, gfn_t gfn, kvm_pfn_t pfn, u64 old_spte, bool prefetch, bool can_unsync, - bool host_writable, u64 *new_spte) + bool host_writable, bool is_refcounted, u64 *new_spte) { int level = sp->role.level;u64 spte =SPTE_MMU_PRESENT_MASK ;
@@ -188,6 +188,8 @@ bool make_spte(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp,if (level >PG_LEVEL_4K ) spte |=PT_PAGE_SIZE_MASK ; +if (is_refcounted) + spte |=SPTE_MMU_PAGE_REFCOUNTED ;if (shadow_memtype_mask) spte |= static_call(kvm_x86_get_mt_mask)(vcpu, gfn,
arch/x86/kvm/mmu/spte.h +11 -1
@@ -95,6 +95,11 @@ static_assert(!(EPT_SPTE_MMU_WRITABLE & SHADOW_ACC_TRACK_SAVED_MASK));/* Defined only to keep the above static asserts readable. */ #undef SHADOW_ACC_TRACK_SAVED_MASK +/* +* Indicates that the SPTE refers to a page with a valid refcount. +*/ +#define SPTE_MMU_PAGE_REFCOUNTED BIT_ULL(59) +/* * Due to limited space in PTEs, the MMIO generation is a 19 bit subset of * the memslots generation and is derived as follows:
@@ -332,6 +337,11 @@ static inline bool is_dirty_spte(u64 spte)return dirty_mask ? spte & dirty_mask : spte &PT_WRITABLE_MASK ; } +static inline bool is_refcounted_page_pte (u64 spte) +{ +return spte &SPTE_MMU_PAGE_REFCOUNTED ; +} +static inline u64 get_rsvd_bits (struct rsvd_bits_validate *rsvd_check,u64 pte,int level) {
@@ -462,7 +472,7 @@ bool make_spte(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp,const struct kvm_memory_slot *slot, unsigned int pte_access, gfn_t gfn, kvm_pfn_t pfn, u64 old_spte, bool prefetch, bool can_unsync, - bool host_writable, u64 *new_spte); + bool host_writable, bool is_refcounted, u64 *new_spte);u64 make_huge_page_split_spte (struct kvm *kvm,u64 huge_spte,union kvm_mmu_page_role role,int index);u64 make_nonleaf_spte (u64 *child_pt,bool ad_disabled);
arch/x86/kvm/mmu/tdp_mmu.c +13 -9
@@ -474,6 +474,7 @@ static void handle_changed_spte(struct kvm *kvm, int as_id, gfn_t gfn,bool was_leaf = was_present &&is_last_spte (old_spte, level);bool is_leaf = is_present &&is_last_spte (new_spte, level);bool pfn_changed =spte_to_pfn (old_spte) !=spte_to_pfn (new_spte); +bool is_refcounted =is_refcounted_page_pte (old_spte);WARN_ON (level >PT64_ROOT_MAX_LEVEL );WARN_ON (level <PG_LEVEL_4K );
@@ -538,9 +539,9 @@ static void handle_changed_spte(struct kvm *kvm, int as_id, gfn_t gfn,if (is_leaf != was_leaf)kvm_update_page_stats (kvm, level, is_leaf ?1 :-1 ); -if (was_leaf &&is_dirty_spte (old_spte) && +if (was_leaf &&is_dirty_spte (old_spte) && is_refcounted && (!is_present || !is_dirty_spte (new_spte) || pfn_changed)) -kvm_set_pfn_dirty (spte_to_pfn (old_spte)); +kvm_set_page_dirty (pfn_to_page (spte_to_pfn (old_spte)));/* * Recursively handle child PTs if the change removed a subtree from
@@ -552,9 +553,9 @@ static void handle_changed_spte(struct kvm *kvm, int as_id, gfn_t gfn, (is_leaf || !is_present || WARN_ON_ONCE(pfn_changed)))handle_removed_pt (kvm,spte_to_child_pt (old_spte, level), shared); -if (was_leaf &&is_accessed_spte (old_spte) && +if (was_leaf &&is_accessed_spte (old_spte) && is_refcounted && (!is_present || !is_accessed_spte (new_spte) || pfn_changed)) -kvm_set_pfn_accessed (spte_to_pfn (old_spte)); +kvm_set_page_accessed (pfn_to_page (spte_to_pfn (old_spte))); }/*
@@ -988,8 +989,9 @@ static int tdp_mmu_map_handle_target_level(struct kvm_vcpu *vcpu, new_spte =make_mmio_spte (vcpu, iter->gfn,ACC_ALL ); else wrprot =make_spte (vcpu, sp, fault->slot,ACC_ALL , iter->gfn, - fault->pfn, iter->old_spte, fault->prefetch, true, - fault->map_writable, &new_spte); + fault->pfn, iter->old_spte, fault->prefetch, true, + fault->map_writable, fault->is_refcounted_page, + &new_spte);if (new_spte == iter->old_spte) ret =RET_PF_SPURIOUS ;
@@ -1205,8 +1207,9 @@ static bool age_gfn_range(struct kvm *kvm, struct tdp_iter *iter,* Capture the dirty status of the page, so that it doesn't get * lost when the SPTE is marked for access tracking. */ -if (is_writable_pte (iter->old_spte)) -kvm_set_pfn_dirty (spte_to_pfn (iter->old_spte)); +if (is_writable_pte (iter->old_spte) && +is_refcounted_page_pte (iter->old_spte)) +kvm_set_page_dirty (pfn_to_page (spte_to_pfn (iter->old_spte))); new_spte =mark_spte_for_access_track (iter->old_spte); iter->old_spte = kvm_tdp_mmu_write_spte(iter->sptep,
@@ -1626,7 +1629,8 @@ static void clear_dirty_pt_masked(struct kvm *kvm, struct kvm_mmu_page *root,trace_kvm_tdp_mmu_spte_changed (iter.as_id, iter.gfn, iter.level, iter.old_spte, iter.old_spte & ~dbit); -kvm_set_pfn_dirty (spte_to_pfn (iter.old_spte)); +if (is_refcounted_page_pte (iter.old_spte)) +kvm_set_page_dirty (pfn_to_page (spte_to_pfn (iter.old_spte))); }rcu_read_unlock ();
include/linux/kvm_host.h +3 -0
@@ -1157,6 +1157,9 @@ unsigned long gfn_to_hva_memslot_prot(struct kvm_memory_slot *slot, gfn_t gfn,void kvm_release_page_clean (struct page *page);void kvm_release_page_dirty (struct page *page); +void kvm_set_page_accessed (struct page *page); +void kvm_set_page_dirty (struct page *page); +struct kvm_follow_pfn {const struct kvm_memory_slot *slot;gfn_t gfn;
virt/kvm/kvm_main.c +4 -2
@@ -2949,17 +2949,19 @@ static bool kvm_is_ad_tracked_page(struct page *page)return !PageReserved (page); } -static void kvm_set_page_dirty (struct page *page) +void kvm_set_page_dirty (struct page *page) {if (kvm_is_ad_tracked_page (page))SetPageDirty (page); } +EXPORT_SYMBOL_GPL (kvm_set_page_dirty); -static void kvm_set_page_accessed (struct page *page) +void kvm_set_page_accessed (struct page *page) {if (kvm_is_ad_tracked_page (page))mark_page_accessed (page); } +EXPORT_SYMBOL_GPL (kvm_set_page_accessed);void kvm_release_page_clean (struct page *page) {
Signature · 1 line
2.42.0.rc1.204.g551eb34607-goog
Re: [PATCH v8 5/8] KVM: x86/mmu: Don't pass FOLL_GET to __kvm_follow_pfn
Quoted 152 lines · David Stevens
From: David Stevens <[email protected]>
Stop passing
FOLL_GETto__kvm_follow_pfn. This allows the host to map memory into the guest that is backed by un-refcounted struct pages - for example, the tail pages of higher order non-compound pages allocated by the amdgpu driver viattm_pool_alloc_page.The bulk of this change is tracking the
is_refcounted_pageflag so that non-refcounted pages don't triggerpage_count()== 0 warnings. This is done by storing the flag in an unused bit in the sptes. This only bit is not available in PAE SPTEs, soFOLL_GETis only omitted for TDP on x86-64.Signed-off-by David Stevens <[email protected]>--- arch/x86/kvm/mmu/mmu.c | 55 +++++++++++++++++++++++---------- arch/x86/kvm/mmu/mmu_internal.h | 1 + arch/x86/kvm/mmu/paging_tmpl.h | 8 +++-- arch/x86/kvm/mmu/spte.c | 4 ++- arch/x86/kvm/mmu/spte.h | 12 ++++++- arch/x86/kvm/mmu/tdp_mmu.c | 22 +++++++------ include/linux/kvm_host.h | 3 ++ virt/kvm/kvm_main.c | 6 ++-- 8 files changed, 79 insertions(+), 32 deletions(-)arch/x86/kvm/mmu/mmu.c +35
-14@@ -553,12 +553,14 @@ static bool mmu_spte_update(u64 *sptep, u64 new_spte)if (is_accessed_spte (old_spte) && !is_accessed_spte (new_spte)) { flush = true; -kvm_set_pfn_accessed (spte_to_pfn (old_spte)); +if (is_refcounted_page_pte (old_spte)) +kvm_set_page_accessed (pfn_to_page (spte_to_pfn (old_spte))); }if (is_dirty_spte (old_spte) && !is_dirty_spte (new_spte)) { flush = true; -kvm_set_pfn_dirty (spte_to_pfn (old_spte)); +if (is_refcounted_page_pte (old_spte)) +kvm_set_page_dirty (pfn_to_page (spte_to_pfn (old_spte))); }return flush;@@ -596,14 +598,18 @@ static u64 mmu_spte_clear_track_bits(struct kvm *kvm, u64 *sptep)* before they are reclaimed. Sanity check that, if the pfn is backed * by a refcounted page, the refcount is elevated. */ - page =kvm_pfn_to_refcounted_page (pfn); -WARN_ON (page && !page_count (page)); +if (is_refcounted_page_pte (old_spte)) { + page =kvm_pfn_to_refcounted_page (pfn); +WARN_ON (!page || !page_count (page)); + } -if (is_accessed_spte (old_spte)) -kvm_set_pfn_accessed (pfn); +if (is_refcounted_page_pte (old_spte)) { +if (is_accessed_spte (old_spte)) +kvm_set_page_accessed (pfn_to_page (pfn)); -if (is_dirty_spte (old_spte)) -kvm_set_pfn_dirty (pfn); +if (is_dirty_spte (old_spte)) +kvm_set_page_dirty (pfn_to_page (pfn)); + }return old_spte; }@@ -639,8 +645,8 @@ static bool mmu_spte_age(u64 *sptep)* Capture the dirty status of the page, so that it doesn't get * lost when the SPTE is marked for access tracking. */ -if (is_writable_pte (spte)) -kvm_set_pfn_dirty (spte_to_pfn (spte)); +if (is_writable_pte (spte) &&is_refcounted_page_pte (spte)) +kvm_set_page_dirty (pfn_to_page (spte_to_pfn (spte))); spte =mark_spte_for_access_track (spte);mmu_spte_update_no_track (sptep, spte);@@ -1278,8 +1284,8 @@ static bool spte_wrprot_for_clear_dirty(u64 *sptep) {bool was_writable =test_and_clear_bit (PT_WRITABLE_SHIFT , (unsigned long *)sptep); -if (was_writable && !spte_ad_enabled (*sptep)) -kvm_set_pfn_dirty (spte_to_pfn (*sptep)); +if (was_writable && !spte_ad_enabled (*sptep) &&is_refcounted_page_pte (*sptep)) +kvm_set_page_dirty (pfn_to_page (spte_to_pfn (*sptep)));return was_writable; }@@ -2937,6 +2943,11 @@ static int mmu_set_spte(struct kvm_vcpu *vcpu, struct kvm_memory_slot *slot,bool host_writable = !fault || fault->map_writable;bool prefetch = !fault || fault->prefetch;bool write_fault = fault && fault->write; +/* +* Prefetching uses gfn_to_page_many_atomic, which never gets +* non-refcounted pages. +*/ +bool is_refcounted = !fault || fault->is_refcounted_page;pgprintk ("%s: spte %llx write_fault %d gfn %llx\n" , __func__, *sptep, write_fault, gfn);@@ -2969,7 +2980,7 @@ static int mmu_set_spte(struct kvm_vcpu *vcpu, struct kvm_memory_slot *slot, } wrprot =make_spte (vcpu, sp, slot, pte_access, gfn, pfn, *sptep, prefetch, - true, host_writable, &spte); + true, host_writable, is_refcounted, &spte);if (*sptep == spte) { ret =RET_PF_SPURIOUS ;@@ -4296,11 +4307,19 @@ void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu, struct kvm_async_pf *work)static int __kvm_faultin_pfn (struct kvm_vcpu *vcpu,struct kvm_page_fault *fault) {struct kvm_memory_slot *slot = fault->slot; +/* +* We only allow non-refcounted pages if we can track whether or not +* pages are refcounted via an SPTE bit. This bit is not available +* in PAE SPTEs, so pass FOLL_GET if we may have to deal with those. +*/ +unsigned int get_flag = (tdp_enabled &&IS_ENABLED (CONFIG_X86_64 )) ? +0 :FOLL_GET ;struct kvm_follow_pfn foll = { .slot = slot, .gfn = fault->gfn, - .flags =FOLL_GET | (fault->write ?FOLL_WRITE :0 ), + .flags = (fault->write ?FOLL_WRITE :0 ) | get_flag, .try_map_writable = true, + .guarded_by_mmu_notifier = true, };/* @@ -4317,6 +4336,7 @@ static int __kvm_faultin_pfn(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault fault->slot =NULL ; fault->pfn =KVM_PFN_NOSLOT ; fault->map_writable = false; + fault->is_refcounted_page = false;return RET_PF_CONTINUE ; }/* @@ -4372,6 +4392,7 @@ static int __kvm_faultin_pfn(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault success: fault->hva = foll.hva; fault->map_writable = foll.writable; + fault->is_refcounted_page = foll.is_refcounted_page;return RET_PF_CONTINUE ; }
arch/x86/kvm/mmu/mmu.c static int direct_page_fault(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault · line 4460
Quoted 7 lines
arch/x86/kvm/mmu/mmu.c +2
-1@@ -4456,8 +4477,9 @@ static int direct_page_fault(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault r =direct_map (vcpu, fault); out_unlock: +if (fault->is_refcounted_page) +kvm_set_page_accessed (pfn_to_page (fault->pfn));write_unlock (&vcpu->kvm->mmu_lock); -kvm_release_pfn_clean (fault->pfn);
Should we check FOLL_GET is actually omitted to skip the kvm_release_pfn_clean() ?
Quoted 232 lines
arch/x86/kvm/mmu/mmu.c +2
-1return r; }@@ -4534,8 +4556,9 @@ static int kvm_tdp_mmu_page_fault(struct kvm_vcpu *vcpu, r =kvm_tdp_mmu_map (vcpu, fault); out_unlock: +if (fault->is_refcounted_page) +kvm_set_page_accessed (pfn_to_page (fault->pfn));read_unlock (&vcpu->kvm->mmu_lock); -kvm_release_pfn_clean (fault->pfn); return r; }#endif arch/x86/kvm/mmu/mmu_internal.h +1
-0@@ -240,6 +240,7 @@ struct kvm_page_fault {kvm_pfn_t pfn;hva_t hva;bool map_writable; +bool is_refcounted_page;/* * Indicates the guest is trying to write a gfn that contains one or arch/x86/kvm/mmu/paging_tmpl.h +5
-3@@ -828,8 +828,9 @@ static int FNAME(page_fault)(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault r =FNAME (fetch)(vcpu, fault, &walker); out_unlock: +if (fault->is_refcounted_page) +kvm_set_page_accessed (pfn_to_page (fault->pfn));write_unlock (&vcpu->kvm->mmu_lock); -kvm_release_pfn_clean (fault->pfn);return r; }@@ -883,7 +884,7 @@ static gpa_t FNAME(gva_to_gpa)(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu,*/ static int FNAME (sync_spte )(struct kvm_vcpu *vcpu,struct kvm_mmu_page *sp,int i) { -bool host_writable; +bool host_writable, is_refcounted;gpa_t first_pte_gpa;u64 *sptep, spte;struct kvm_memory_slot *slot;@@ -940,10 +941,11 @@ static int FNAME(sync_spte)(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp, int sptep = &sp->spt[i]; spte = *sptep; host_writable = spte & shadow_host_writable_mask; + is_refcounted = spte &SPTE_MMU_PAGE_REFCOUNTED ; slot =kvm_vcpu_gfn_to_memslot (vcpu, gfn);make_spte (vcpu, sp, slot, pte_access, gfn,spte_to_pfn (spte), spte, true, false, - host_writable, &spte); + host_writable, is_refcounted, &spte);return mmu_spte_update (sptep, spte); }arch/x86/kvm/mmu/spte.c +3
-1@@ -138,7 +138,7 @@ bool make_spte(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp,const struct kvm_memory_slot *slot, unsigned int pte_access, gfn_t gfn, kvm_pfn_t pfn, u64 old_spte, bool prefetch, bool can_unsync, - bool host_writable, u64 *new_spte) + bool host_writable, bool is_refcounted, u64 *new_spte) { int level = sp->role.level;u64 spte =SPTE_MMU_PRESENT_MASK ;@@ -188,6 +188,8 @@ bool make_spte(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp,if (level >PG_LEVEL_4K ) spte |=PT_PAGE_SIZE_MASK ; +if (is_refcounted) + spte |=SPTE_MMU_PAGE_REFCOUNTED ;if (shadow_memtype_mask) spte |= static_call(kvm_x86_get_mt_mask)(vcpu, gfn,arch/x86/kvm/mmu/spte.h +11
-1@@ -95,6 +95,11 @@ static_assert(!(EPT_SPTE_MMU_WRITABLE & SHADOW_ACC_TRACK_SAVED_MASK));/* Defined only to keep the above static asserts readable. */ #undef SHADOW_ACC_TRACK_SAVED_MASK +/* +* Indicates that the SPTE refers to a page with a valid refcount. +*/ +#define SPTE_MMU_PAGE_REFCOUNTED BIT_ULL(59) +/* * Due to limited space in PTEs, the MMIO generation is a 19 bit subset of * the memslots generation and is derived as follows: @@ -332,6 +337,11 @@ static inline bool is_dirty_spte(u64 spte)return dirty_mask ? spte & dirty_mask : spte &PT_WRITABLE_MASK ; } +static inline bool is_refcounted_page_pte (u64 spte) +{ +return spte &SPTE_MMU_PAGE_REFCOUNTED ; +} +static inline u64 get_rsvd_bits (struct rsvd_bits_validate *rsvd_check,u64 pte,int level) {@@ -462,7 +472,7 @@ bool make_spte(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp,const struct kvm_memory_slot *slot, unsigned int pte_access, gfn_t gfn, kvm_pfn_t pfn, u64 old_spte, bool prefetch, bool can_unsync, - bool host_writable, u64 *new_spte); + bool host_writable, bool is_refcounted, u64 *new_spte);u64 make_huge_page_split_spte (struct kvm *kvm,u64 huge_spte,union kvm_mmu_page_role role,int index);u64 make_nonleaf_spte (u64 *child_pt,bool ad_disabled);arch/x86/kvm/mmu/tdp_mmu.c +13
-9@@ -474,6 +474,7 @@ static void handle_changed_spte(struct kvm *kvm, int as_id, gfn_t gfn,bool was_leaf = was_present &&is_last_spte (old_spte, level);bool is_leaf = is_present &&is_last_spte (new_spte, level);bool pfn_changed =spte_to_pfn (old_spte) !=spte_to_pfn (new_spte); +bool is_refcounted =is_refcounted_page_pte (old_spte);WARN_ON (level >PT64_ROOT_MAX_LEVEL );WARN_ON (level <PG_LEVEL_4K );@@ -538,9 +539,9 @@ static void handle_changed_spte(struct kvm *kvm, int as_id, gfn_t gfn,if (is_leaf != was_leaf)kvm_update_page_stats (kvm, level, is_leaf ?1 :-1 ); -if (was_leaf &&is_dirty_spte (old_spte) && +if (was_leaf &&is_dirty_spte (old_spte) && is_refcounted && (!is_present || !is_dirty_spte (new_spte) || pfn_changed)) -kvm_set_pfn_dirty (spte_to_pfn (old_spte)); +kvm_set_page_dirty (pfn_to_page (spte_to_pfn (old_spte)));/* * Recursively handle child PTs if the change removed a subtree from @@ -552,9 +553,9 @@ static void handle_changed_spte(struct kvm *kvm, int as_id, gfn_t gfn, (is_leaf || !is_present || WARN_ON_ONCE(pfn_changed)))handle_removed_pt (kvm,spte_to_child_pt (old_spte, level), shared); -if (was_leaf &&is_accessed_spte (old_spte) && +if (was_leaf &&is_accessed_spte (old_spte) && is_refcounted && (!is_present || !is_accessed_spte (new_spte) || pfn_changed)) -kvm_set_pfn_accessed (spte_to_pfn (old_spte)); +kvm_set_page_accessed (pfn_to_page (spte_to_pfn (old_spte))); }/* @@ -988,8 +989,9 @@ static int tdp_mmu_map_handle_target_level(struct kvm_vcpu *vcpu, new_spte =make_mmio_spte (vcpu, iter->gfn,ACC_ALL ); else wrprot =make_spte (vcpu, sp, fault->slot,ACC_ALL , iter->gfn, - fault->pfn, iter->old_spte, fault->prefetch, true, - fault->map_writable, &new_spte); + fault->pfn, iter->old_spte, fault->prefetch, true, + fault->map_writable, fault->is_refcounted_page, + &new_spte);if (new_spte == iter->old_spte) ret =RET_PF_SPURIOUS ;@@ -1205,8 +1207,9 @@ static bool age_gfn_range(struct kvm *kvm, struct tdp_iter *iter,* Capture the dirty status of the page, so that it doesn't get * lost when the SPTE is marked for access tracking. */ -if (is_writable_pte (iter->old_spte)) -kvm_set_pfn_dirty (spte_to_pfn (iter->old_spte)); +if (is_writable_pte (iter->old_spte) && +is_refcounted_page_pte (iter->old_spte)) +kvm_set_page_dirty (pfn_to_page (spte_to_pfn (iter->old_spte))); new_spte =mark_spte_for_access_track (iter->old_spte); iter->old_spte = kvm_tdp_mmu_write_spte(iter->sptep,@@ -1626,7 +1629,8 @@ static void clear_dirty_pt_masked(struct kvm *kvm, struct kvm_mmu_page *root,trace_kvm_tdp_mmu_spte_changed (iter.as_id, iter.gfn, iter.level, iter.old_spte, iter.old_spte & ~dbit); -kvm_set_pfn_dirty (spte_to_pfn (iter.old_spte)); +if (is_refcounted_page_pte (iter.old_spte)) +kvm_set_page_dirty (pfn_to_page (spte_to_pfn (iter.old_spte))); }rcu_read_unlock ();include/linux/kvm_host.h +3
-0@@ -1157,6 +1157,9 @@ unsigned long gfn_to_hva_memslot_prot(struct kvm_memory_slot *slot, gfn_t gfn,void kvm_release_page_clean (struct page *page);void kvm_release_page_dirty (struct page *page); +void kvm_set_page_accessed (struct page *page); +void kvm_set_page_dirty (struct page *page); +struct kvm_follow_pfn {const struct kvm_memory_slot *slot;gfn_t gfn;virt/kvm/kvm_main.c +4
-2@@ -2949,17 +2949,19 @@ static bool kvm_is_ad_tracked_page(struct page *page)return !PageReserved (page); } -static void kvm_set_page_dirty (struct page *page) +void kvm_set_page_dirty (struct page *page) {if (kvm_is_ad_tracked_page (page))SetPageDirty (page); } +EXPORT_SYMBOL_GPL (kvm_set_page_dirty); -static void kvm_set_page_accessed (struct page *page) +void kvm_set_page_accessed (struct page *page) {if (kvm_is_ad_tracked_page (page))mark_page_accessed (page); } +EXPORT_SYMBOL_GPL (kvm_set_page_accessed);void kvm_release_page_clean (struct page *page) {
PATCH v8 6/8 KVM: arm64: Migrate to __kvm_follow_pfn
In reply to David StevensFrom: David Stevens <[email protected]>
Migrate from __gfn_to_pfn_memslot to __kvm_follow_pfn.
--- arch/arm64/kvm/mmu.c | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-)
arch/arm64/kvm/mmu.c +14 -11
@@ -1334,7 +1334,8 @@ static int user_mem_abort(struct kvm_vcpu *vcpu, phys_addr_t fault_ipa, unsigned long fault_status) {int ret =0 ; -bool write_fault, writable, force_pte = false; +bool write_fault =kvm_is_write_fault (vcpu); +bool force_pte = false;bool exec_fault, mte_allowed;bool device = false;unsigned long mmu_seq;
@@ -1342,16 +1343,19 @@ static int user_mem_abort(struct kvm_vcpu *vcpu, phys_addr_t fault_ipa,struct kvm_mmu_memory_cache *memcache = &vcpu->arch.mmu_page_cache;struct vm_area_struct *vma;short vma_shift; -gfn_t gfn;kvm_pfn_t pfn;bool logging_active =memslot_is_logging (memslot);unsigned long fault_level =kvm_vcpu_trap_get_fault_level (vcpu);long vma_pagesize, fault_granule;enum kvm_pgtable_prot prot =KVM_PGTABLE_PROT_R ;struct kvm_pgtable *pgt; +struct kvm_follow_pfn foll = { + .slot = memslot, + .flags =FOLL_GET | (write_fault ?FOLL_WRITE :0 ), + .try_map_writable = true, + }; fault_granule =1UL <<ARM64_HW_PGTABLE_LEVEL_SHIFT (fault_level); - write_fault =kvm_is_write_fault (vcpu); exec_fault =kvm_vcpu_trap_is_exec_fault (vcpu);VM_BUG_ON (write_fault && exec_fault);
@@ -1425,7 +1429,7 @@ static int user_mem_abort(struct kvm_vcpu *vcpu, phys_addr_t fault_ipa,if (vma_pagesize ==PMD_SIZE || vma_pagesize ==PUD_SIZE ) fault_ipa &= ~(vma_pagesize -1 ); - gfn = fault_ipa >>PAGE_SHIFT ; + foll.gfn = fault_ipa >>PAGE_SHIFT ; mte_allowed =kvm_vma_mte_allowed (vma);/* Don't use the VMA after the unlock -- it may have vanished */
@@ -1433,7 +1437,7 @@ static int user_mem_abort(struct kvm_vcpu *vcpu, phys_addr_t fault_ipa,/* * Read mmu_invalidate_seq so that KVM can detect if the results of -* vma_lookup() or __gfn_to_pfn_memslot() become stale prior to +* vma_lookup() or __kvm_follow_pfn() become stale prior to * acquiring kvm->mmu_lock. * * Rely on mmap_read_unlock() for an implicit smp_rmb(), which pairs
@@ -1442,8 +1446,7 @@ static int user_mem_abort(struct kvm_vcpu *vcpu, phys_addr_t fault_ipa, mmu_seq = vcpu->kvm->mmu_invalidate_seq;mmap_read_unlock (current->mm); - pfn =__gfn_to_pfn_memslot (memslot, gfn, false, false,NULL , - write_fault, &writable,NULL ); + pfn =__kvm_follow_pfn (&foll);if (pfn ==KVM_PFN_ERR_HWPOISON ) {kvm_send_hwpoison_signal (hva, vma_shift);return 0 ;
@@ -1468,7 +1471,7 @@ static int user_mem_abort(struct kvm_vcpu *vcpu, phys_addr_t fault_ipa,* Only actually map the page as writable if this was a write * fault. */ - writable = false; + foll.writable = false; }if (exec_fault && device)
@@ -1508,7 +1511,7 @@ static int user_mem_abort(struct kvm_vcpu *vcpu, phys_addr_t fault_ipa, } } -if (writable) +if (foll.writable) prot |=KVM_PGTABLE_PROT_W ;if (exec_fault)
@@ -1534,9 +1537,9 @@ static int user_mem_abort(struct kvm_vcpu *vcpu, phys_addr_t fault_ipa, KVM_PGTABLE_WALK_SHARED);/* Mark the page dirty only if the fault is handled successfully */ -if (writable && !ret) { +if (foll.writable && !ret) {kvm_set_pfn_dirty (pfn); -mark_page_dirty_in_slot (kvm, memslot, gfn); +mark_page_dirty_in_slot (kvm, memslot, foll.gfn); } out_unlock:
Signature · 1 line
2.42.0.rc1.204.g551eb34607-goog
PATCH v8 7/8 KVM: PPC: Migrate to __kvm_follow_pfn
In reply to David StevensFrom: David Stevens <[email protected]>
Migrate from __gfn_to_pfn_memslot to __kvm_follow_pfn. As part of the refactoring, remove the redundant calls to get_user_page_fast_only, since the check for !async && !atomic was removed from the KVM generic code in b9b33da2aa74. Also, remove the kvm_ro parameter because the KVM generic code handles RO memslots.
--- arch/powerpc/include/asm/kvm_book3s.h | 2 +- arch/powerpc/kvm/book3s_64_mmu_hv.c | 38 +++++++++----------- arch/powerpc/kvm/book3s_64_mmu_radix.c | 50 +++++++++++--------------- arch/powerpc/kvm/book3s_hv_nested.c | 4 +-- 4 files changed, 38 insertions(+), 56 deletions(-)
arch/powerpc/include/asm/kvm_book3s.h +1 -1
@@ -202,7 +202,7 @@ extern bool kvmppc_hv_handle_set_rc(struct kvm *kvm, bool nested,extern int kvmppc_book3s_instantiate_page (struct kvm_vcpu *vcpu,unsigned long gpa,struct kvm_memory_slot *memslot, -bool writing,bool kvm_ro, +bool writing,pte_t *inserted_pte,unsigned int *levelp);extern int kvmppc_init_vm_radix (struct kvm *kvm);extern void kvmppc_free_radix (struct kvm *kvm);
arch/powerpc/kvm/book3s_64_mmu_hv.c +16 -22
@@ -523,6 +523,9 @@ int kvmppc_book3s_hv_page_fault(struct kvm_vcpu *vcpu,unsigned long rcbits;long mmio_update;pte_t pte, *ptep; +struct kvm_follow_pfn foll = { + .try_map_writable = true, + };if (kvm_is_radix (kvm))return kvmppc_book3s_radix_page_fault (vcpu, ea, dsisr);
@@ -599,29 +602,20 @@ int kvmppc_book3s_hv_page_fault(struct kvm_vcpu *vcpu, page =NULL ; writing = (dsisr &DSISR_ISSTORE ) !=0 ;/* If writing != 0, then the HPTE must allow writing, if we get here */ - write_ok = writing; - hva =gfn_to_hva_memslot (memslot, gfn); -/* -* Do a fast check first, since __gfn_to_pfn_memslot doesn't -* do it with !atomic && !async, which is how we call it. -* We always ask for write permission since the common case -* is that the page is writable. -*/ -if (get_user_page_fast_only (hva,FOLL_WRITE , &page)) { - write_ok = true; - }else { -/* Call KVM generic code to do the slow-path check */ - pfn =__gfn_to_pfn_memslot (memslot, gfn, false, false,NULL , - writing, &write_ok,NULL ); -if (is_error_noslot_pfn (pfn)) -return -EFAULT ; - page =NULL ; -if (pfn_valid (pfn)) { - page =pfn_to_page (pfn); -if (PageReserved (page)) - page =NULL ; - } + foll.slot = memslot; + foll.gfn = gfn; + foll.flags =FOLL_GET | (writing ?FOLL_WRITE :0 ); + pfn =__kvm_follow_pfn (&foll); +if (is_error_noslot_pfn (pfn)) +return -EFAULT ; + page =NULL ; + write_ok = foll.writable; + hva = foll.hva; +if (pfn_valid (pfn)) { + page =pfn_to_page (pfn); +if (PageReserved (page)) + page =NULL ; }/*
arch/powerpc/kvm/book3s_64_mmu_radix.c +20 -30
88 lines not on this page · raw message
arch/powerpc/kvm/book3s_hv_nested.c +1 -3
@@ -1497,7 +1497,6 @@ static long int __kvmhv_nested_page_fault(struct kvm_vcpu *vcpu,unsigned long n_gpa, gpa, gfn, perm =0UL ;unsigned int shift, l1_shift, level;bool writing = !!(dsisr &DSISR_ISSTORE ); -bool kvm_ro = false;long int ret;if (!gp->l1_gr_to_hr) {
@@ -1577,7 +1576,6 @@ static long int __kvmhv_nested_page_fault(struct kvm_vcpu *vcpu, ea, DSISR_ISSTORE | DSISR_PROTFAULT);return RESUME_GUEST ; } - kvm_ro = true; }/* 2. Find the host pte for this L1 guest real address */
@@ -1599,7 +1597,7 @@ static long int __kvmhv_nested_page_fault(struct kvm_vcpu *vcpu,if (!pte_present (pte) || (writing && !(pte_val (pte) & _PAGE_WRITE))) {/* No suitable pte found -> try to insert a mapping */ ret =kvmppc_book3s_instantiate_page (vcpu, gpa, memslot, - writing, kvm_ro, &pte, &level); + writing, &pte, &level);if (ret == -EAGAIN )return RESUME_GUEST ;else if (ret)
Signature · 1 line
2.42.0.rc1.204.g551eb34607-goog
PATCH v8 8/8 KVM: mmu: remove __gfn_to_pfn_memslot
In reply to David StevensFrom: David Stevens <[email protected]>
All callers have been migrated to __kvm_follow_pfn.
--- virt/kvm/kvm_main.c | 33 --------------------------------- 1 file changed, 33 deletions(-)
virt/kvm/kvm_main.c +0 -33
@@ -2728,39 +2728,6 @@ kvm_pfn_t __kvm_follow_pfn(struct kvm_follow_pfn *foll) }EXPORT_SYMBOL_GPL (__kvm_follow_pfn); -kvm_pfn_t __gfn_to_pfn_memslot (const struct kvm_memory_slot *slot,gfn_t gfn, -bool atomic,bool interruptible,bool *async, -bool write_fault,bool *writable,hva_t *hva) -{ -kvm_pfn_t pfn; -struct kvm_follow_pfn foll = { - .slot = slot, - .gfn = gfn, - .flags =FOLL_GET , - .atomic = atomic, - .try_map_writable = !!writable, - }; - -if (write_fault) - foll.flags |=FOLL_WRITE ; -if (async) - foll.flags |=FOLL_NOWAIT ; -if (interruptible) - foll.flags |=FOLL_INTERRUPTIBLE ; - - pfn =__kvm_follow_pfn (&foll); -if (pfn ==KVM_PFN_ERR_NEEDS_IO ) { - *async = true; - pfn =KVM_PFN_ERR_FAULT ; - } -if (hva) - *hva = foll.hva; -if (writable) - *writable = foll.writable; -return pfn; -} -EXPORT_SYMBOL_GPL (__gfn_to_pfn_memslot); -kvm_pfn_t gfn_to_pfn_prot (struct kvm *kvm,gfn_t gfn,bool write_fault,bool *writable) {
Signature · 1 line
2.42.0.rc1.204.g551eb34607-goog