mirrors/linux
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2026-02-25 11:08:01 -05:00
Code Issues Packages Projects Releases Wiki Activity

KVM: Move x86's API to release a faultin page to common KVM

Browse Source 
Move KVM x86's helper that "finishes" the faultin process to common KVM
so that the logic can be shared across all architectures.  Note, not all
architectures implement a fast page fault path, but the gist of the
comment applies to all architectures.

Tested-by: Alex Bennée <alex.bennee@linaro.org>
Signed-off-by: Sean Christopherson <seanjc@google.com>
Tested-by: Dmitry Osipenko <dmitry.osipenko@collabora.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-ID: <20241010182427.1434605-50-seanjc@google.com>
This commit is contained in:
Sean Christopherson
2024-10-10 11:23:51 -07:00
committed by Paolo Bonzini
parent 8eaa98004b
commit dc06193532
2 changed files with 28 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
arch/x86/kvm/mmu/mmu.c
View File

@@ -4377,28 +4377,8 @@ static u8 kvm_max_private_mapping_level(struct kvm *kvm, kvm_pfn_t pfn,
static void kvm_mmu_finish_page_fault(struct kvm_vcpu *vcpu,
struct kvm_page_fault *fault, int r)
{
lockdep_assert_once(lockdep_is_held(&vcpu->kvm->mmu_lock) ||
r == RET_PF_RETRY);
if (!fault->refcounted_page)
return;
/*
* If the page that KVM got from the *primary MMU* is writable, and KVM
* installed or reused a SPTE, mark the page/folio dirty. Note, this
* may mark a folio dirty even if KVM created a read-only SPTE, e.g. if
* the GFN is write-protected. Folios can't be safely marked dirty
* outside of mmu_lock as doing so could race with writeback on the
* folio. As a result, KVM can't mark folios dirty in the fast page
* fault handler, and so KVM must (somewhat) speculatively mark the
* folio dirty if KVM could locklessly make the SPTE writable.
*/
if (r == RET_PF_RETRY)
kvm_release_page_unused(fault->refcounted_page);
else if (!fault->map_writable)
kvm_release_page_clean(fault->refcounted_page);
else
kvm_release_page_dirty(fault->refcounted_page);
kvm_release_faultin_page(vcpu->kvm, fault->refcounted_page,
r == RET_PF_RETRY, fault->map_writable);
}
static int kvm_mmu_faultin_pfn_private(struct kvm_vcpu *vcpu,

26
include/linux/kvm_host.h
View File

@@ -1231,6 +1231,32 @@ static inline void kvm_release_page_unused(struct page *page)
void kvm_release_page_clean(struct page *page);
void kvm_release_page_dirty(struct page *page);
static inline void kvm_release_faultin_page(struct kvm *kvm, struct page *page,
bool unused, bool dirty)
{
lockdep_assert_once(lockdep_is_held(&kvm->mmu_lock) || unused);
if (!page)
return;
/*
* If the page that KVM got from the *primary MMU* is writable, and KVM
* installed or reused a SPTE, mark the page/folio dirty. Note, this
* may mark a folio dirty even if KVM created a read-only SPTE, e.g. if
* the GFN is write-protected. Folios can't be safely marked dirty
* outside of mmu_lock as doing so could race with writeback on the
* folio. As a result, KVM can't mark folios dirty in the fast page
* fault handler, and so KVM must (somewhat) speculatively mark the
* folio dirty if KVM could locklessly make the SPTE writable.
*/
if (unused)
kvm_release_page_unused(page);
else if (dirty)
kvm_release_page_dirty(page);
else
kvm_release_page_clean(page);
}
kvm_pfn_t __kvm_faultin_pfn(const struct kvm_memory_slot *slot, gfn_t gfn,
unsigned int foll, bool *writable,
struct page **refcounted_page);