mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-21 16:29:59 +00:00
![Sean Christopherson](/assets/img/avatar_default.png)
When refreshing a gfn=>pfn cache, skip straight to unlocking if the cache already valid instead of stuffing the "old" variables to turn the unmapping outro into a nop. Signed-off-by: Sean Christopherson <seanjc@google.com> Signed-off-by: David Woodhouse <dwmw@amazon.co.uk>
418 lines
11 KiB
C
418 lines
11 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* Kernel-based Virtual Machine driver for Linux
|
|
*
|
|
* This module enables kernel and guest-mode vCPU access to guest physical
|
|
* memory with suitable invalidation mechanisms.
|
|
*
|
|
* Copyright © 2021 Amazon.com, Inc. or its affiliates.
|
|
*
|
|
* Authors:
|
|
* David Woodhouse <dwmw2@infradead.org>
|
|
*/
|
|
|
|
#include <linux/kvm_host.h>
|
|
#include <linux/kvm.h>
|
|
#include <linux/highmem.h>
|
|
#include <linux/module.h>
|
|
#include <linux/errno.h>
|
|
|
|
#include "kvm_mm.h"
|
|
|
|
/*
|
|
* MMU notifier 'invalidate_range_start' hook.
|
|
*/
|
|
void gfn_to_pfn_cache_invalidate_start(struct kvm *kvm, unsigned long start,
|
|
unsigned long end, bool may_block)
|
|
{
|
|
DECLARE_BITMAP(vcpu_bitmap, KVM_MAX_VCPUS);
|
|
struct gfn_to_pfn_cache *gpc;
|
|
bool evict_vcpus = false;
|
|
|
|
spin_lock(&kvm->gpc_lock);
|
|
list_for_each_entry(gpc, &kvm->gpc_list, list) {
|
|
write_lock_irq(&gpc->lock);
|
|
|
|
/* Only a single page so no need to care about length */
|
|
if (gpc->valid && !is_error_noslot_pfn(gpc->pfn) &&
|
|
gpc->uhva >= start && gpc->uhva < end) {
|
|
gpc->valid = false;
|
|
|
|
/*
|
|
* If a guest vCPU could be using the physical address,
|
|
* it needs to be forced out of guest mode.
|
|
*/
|
|
if (gpc->usage & KVM_GUEST_USES_PFN) {
|
|
if (!evict_vcpus) {
|
|
evict_vcpus = true;
|
|
bitmap_zero(vcpu_bitmap, KVM_MAX_VCPUS);
|
|
}
|
|
__set_bit(gpc->vcpu->vcpu_idx, vcpu_bitmap);
|
|
}
|
|
}
|
|
write_unlock_irq(&gpc->lock);
|
|
}
|
|
spin_unlock(&kvm->gpc_lock);
|
|
|
|
if (evict_vcpus) {
|
|
/*
|
|
* KVM needs to ensure the vCPU is fully out of guest context
|
|
* before allowing the invalidation to continue.
|
|
*/
|
|
unsigned int req = KVM_REQ_OUTSIDE_GUEST_MODE;
|
|
bool called;
|
|
|
|
/*
|
|
* If the OOM reaper is active, then all vCPUs should have
|
|
* been stopped already, so perform the request without
|
|
* KVM_REQUEST_WAIT and be sad if any needed to be IPI'd.
|
|
*/
|
|
if (!may_block)
|
|
req &= ~KVM_REQUEST_WAIT;
|
|
|
|
called = kvm_make_vcpus_request_mask(kvm, req, vcpu_bitmap);
|
|
|
|
WARN_ON_ONCE(called && !may_block);
|
|
}
|
|
}
|
|
|
|
bool kvm_gpc_check(struct gfn_to_pfn_cache *gpc, unsigned long len)
|
|
{
|
|
struct kvm_memslots *slots = kvm_memslots(gpc->kvm);
|
|
|
|
if (!gpc->active)
|
|
return false;
|
|
|
|
if ((gpc->gpa & ~PAGE_MASK) + len > PAGE_SIZE)
|
|
return false;
|
|
|
|
if (gpc->generation != slots->generation || kvm_is_error_hva(gpc->uhva))
|
|
return false;
|
|
|
|
if (!gpc->valid)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
EXPORT_SYMBOL_GPL(kvm_gpc_check);
|
|
|
|
static void gpc_unmap_khva(kvm_pfn_t pfn, void *khva)
|
|
{
|
|
/* Unmap the old pfn/page if it was mapped before. */
|
|
if (!is_error_noslot_pfn(pfn) && khva) {
|
|
if (pfn_valid(pfn))
|
|
kunmap(pfn_to_page(pfn));
|
|
#ifdef CONFIG_HAS_IOMEM
|
|
else
|
|
memunmap(khva);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
static inline bool mmu_notifier_retry_cache(struct kvm *kvm, unsigned long mmu_seq)
|
|
{
|
|
/*
|
|
* mn_active_invalidate_count acts for all intents and purposes
|
|
* like mmu_invalidate_in_progress here; but the latter cannot
|
|
* be used here because the invalidation of caches in the
|
|
* mmu_notifier event occurs _before_ mmu_invalidate_in_progress
|
|
* is elevated.
|
|
*
|
|
* Note, it does not matter that mn_active_invalidate_count
|
|
* is not protected by gpc->lock. It is guaranteed to
|
|
* be elevated before the mmu_notifier acquires gpc->lock, and
|
|
* isn't dropped until after mmu_invalidate_seq is updated.
|
|
*/
|
|
if (kvm->mn_active_invalidate_count)
|
|
return true;
|
|
|
|
/*
|
|
* Ensure mn_active_invalidate_count is read before
|
|
* mmu_invalidate_seq. This pairs with the smp_wmb() in
|
|
* mmu_notifier_invalidate_range_end() to guarantee either the
|
|
* old (non-zero) value of mn_active_invalidate_count or the
|
|
* new (incremented) value of mmu_invalidate_seq is observed.
|
|
*/
|
|
smp_rmb();
|
|
return kvm->mmu_invalidate_seq != mmu_seq;
|
|
}
|
|
|
|
static kvm_pfn_t hva_to_pfn_retry(struct gfn_to_pfn_cache *gpc)
|
|
{
|
|
/* Note, the new page offset may be different than the old! */
|
|
void *old_khva = gpc->khva - offset_in_page(gpc->khva);
|
|
kvm_pfn_t new_pfn = KVM_PFN_ERR_FAULT;
|
|
void *new_khva = NULL;
|
|
unsigned long mmu_seq;
|
|
|
|
lockdep_assert_held(&gpc->refresh_lock);
|
|
|
|
lockdep_assert_held_write(&gpc->lock);
|
|
|
|
/*
|
|
* Invalidate the cache prior to dropping gpc->lock, the gpa=>uhva
|
|
* assets have already been updated and so a concurrent check() from a
|
|
* different task may not fail the gpa/uhva/generation checks.
|
|
*/
|
|
gpc->valid = false;
|
|
|
|
do {
|
|
mmu_seq = gpc->kvm->mmu_invalidate_seq;
|
|
smp_rmb();
|
|
|
|
write_unlock_irq(&gpc->lock);
|
|
|
|
/*
|
|
* If the previous iteration "failed" due to an mmu_notifier
|
|
* event, release the pfn and unmap the kernel virtual address
|
|
* from the previous attempt. Unmapping might sleep, so this
|
|
* needs to be done after dropping the lock. Opportunistically
|
|
* check for resched while the lock isn't held.
|
|
*/
|
|
if (new_pfn != KVM_PFN_ERR_FAULT) {
|
|
/*
|
|
* Keep the mapping if the previous iteration reused
|
|
* the existing mapping and didn't create a new one.
|
|
*/
|
|
if (new_khva != old_khva)
|
|
gpc_unmap_khva(new_pfn, new_khva);
|
|
|
|
kvm_release_pfn_clean(new_pfn);
|
|
|
|
cond_resched();
|
|
}
|
|
|
|
/* We always request a writeable mapping */
|
|
new_pfn = hva_to_pfn(gpc->uhva, false, false, NULL, true, NULL);
|
|
if (is_error_noslot_pfn(new_pfn))
|
|
goto out_error;
|
|
|
|
/*
|
|
* Obtain a new kernel mapping if KVM itself will access the
|
|
* pfn. Note, kmap() and memremap() can both sleep, so this
|
|
* too must be done outside of gpc->lock!
|
|
*/
|
|
if (gpc->usage & KVM_HOST_USES_PFN) {
|
|
if (new_pfn == gpc->pfn) {
|
|
new_khva = old_khva;
|
|
} else if (pfn_valid(new_pfn)) {
|
|
new_khva = kmap(pfn_to_page(new_pfn));
|
|
#ifdef CONFIG_HAS_IOMEM
|
|
} else {
|
|
new_khva = memremap(pfn_to_hpa(new_pfn), PAGE_SIZE, MEMREMAP_WB);
|
|
#endif
|
|
}
|
|
if (!new_khva) {
|
|
kvm_release_pfn_clean(new_pfn);
|
|
goto out_error;
|
|
}
|
|
}
|
|
|
|
write_lock_irq(&gpc->lock);
|
|
|
|
/*
|
|
* Other tasks must wait for _this_ refresh to complete before
|
|
* attempting to refresh.
|
|
*/
|
|
WARN_ON_ONCE(gpc->valid);
|
|
} while (mmu_notifier_retry_cache(gpc->kvm, mmu_seq));
|
|
|
|
gpc->valid = true;
|
|
gpc->pfn = new_pfn;
|
|
gpc->khva = new_khva + (gpc->gpa & ~PAGE_MASK);
|
|
|
|
/*
|
|
* Put the reference to the _new_ pfn. The pfn is now tracked by the
|
|
* cache and can be safely migrated, swapped, etc... as the cache will
|
|
* invalidate any mappings in response to relevant mmu_notifier events.
|
|
*/
|
|
kvm_release_pfn_clean(new_pfn);
|
|
|
|
return 0;
|
|
|
|
out_error:
|
|
write_lock_irq(&gpc->lock);
|
|
|
|
return -EFAULT;
|
|
}
|
|
|
|
static int __kvm_gpc_refresh(struct gfn_to_pfn_cache *gpc, gpa_t gpa,
|
|
unsigned long len)
|
|
{
|
|
struct kvm_memslots *slots = kvm_memslots(gpc->kvm);
|
|
unsigned long page_offset = gpa & ~PAGE_MASK;
|
|
bool unmap_old = false;
|
|
unsigned long old_uhva;
|
|
kvm_pfn_t old_pfn;
|
|
void *old_khva;
|
|
int ret;
|
|
|
|
/*
|
|
* If must fit within a single page. The 'len' argument is
|
|
* only to enforce that.
|
|
*/
|
|
if (page_offset + len > PAGE_SIZE)
|
|
return -EINVAL;
|
|
|
|
/*
|
|
* If another task is refreshing the cache, wait for it to complete.
|
|
* There is no guarantee that concurrent refreshes will see the same
|
|
* gpa, memslots generation, etc..., so they must be fully serialized.
|
|
*/
|
|
mutex_lock(&gpc->refresh_lock);
|
|
|
|
write_lock_irq(&gpc->lock);
|
|
|
|
if (!gpc->active) {
|
|
ret = -EINVAL;
|
|
goto out_unlock;
|
|
}
|
|
|
|
old_pfn = gpc->pfn;
|
|
old_khva = gpc->khva - offset_in_page(gpc->khva);
|
|
old_uhva = gpc->uhva;
|
|
|
|
/* If the userspace HVA is invalid, refresh that first */
|
|
if (gpc->gpa != gpa || gpc->generation != slots->generation ||
|
|
kvm_is_error_hva(gpc->uhva)) {
|
|
gfn_t gfn = gpa_to_gfn(gpa);
|
|
|
|
gpc->gpa = gpa;
|
|
gpc->generation = slots->generation;
|
|
gpc->memslot = __gfn_to_memslot(slots, gfn);
|
|
gpc->uhva = gfn_to_hva_memslot(gpc->memslot, gfn);
|
|
|
|
if (kvm_is_error_hva(gpc->uhva)) {
|
|
ret = -EFAULT;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If the userspace HVA changed or the PFN was already invalid,
|
|
* drop the lock and do the HVA to PFN lookup again.
|
|
*/
|
|
if (!gpc->valid || old_uhva != gpc->uhva) {
|
|
ret = hva_to_pfn_retry(gpc);
|
|
} else {
|
|
/*
|
|
* If the HVA→PFN mapping was already valid, don't unmap it.
|
|
* But do update gpc->khva because the offset within the page
|
|
* may have changed.
|
|
*/
|
|
gpc->khva = old_khva + page_offset;
|
|
ret = 0;
|
|
goto out_unlock;
|
|
}
|
|
|
|
out:
|
|
/*
|
|
* Invalidate the cache and purge the pfn/khva if the refresh failed.
|
|
* Some/all of the uhva, gpa, and memslot generation info may still be
|
|
* valid, leave it as is.
|
|
*/
|
|
if (ret) {
|
|
gpc->valid = false;
|
|
gpc->pfn = KVM_PFN_ERR_FAULT;
|
|
gpc->khva = NULL;
|
|
}
|
|
|
|
/* Detect a pfn change before dropping the lock! */
|
|
unmap_old = (old_pfn != gpc->pfn);
|
|
|
|
out_unlock:
|
|
write_unlock_irq(&gpc->lock);
|
|
|
|
mutex_unlock(&gpc->refresh_lock);
|
|
|
|
if (unmap_old)
|
|
gpc_unmap_khva(old_pfn, old_khva);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int kvm_gpc_refresh(struct gfn_to_pfn_cache *gpc, unsigned long len)
|
|
{
|
|
return __kvm_gpc_refresh(gpc, gpc->gpa, len);
|
|
}
|
|
EXPORT_SYMBOL_GPL(kvm_gpc_refresh);
|
|
|
|
void kvm_gpc_init(struct gfn_to_pfn_cache *gpc, struct kvm *kvm,
|
|
struct kvm_vcpu *vcpu, enum pfn_cache_usage usage)
|
|
{
|
|
WARN_ON_ONCE(!usage || (usage & KVM_GUEST_AND_HOST_USE_PFN) != usage);
|
|
WARN_ON_ONCE((usage & KVM_GUEST_USES_PFN) && !vcpu);
|
|
|
|
rwlock_init(&gpc->lock);
|
|
mutex_init(&gpc->refresh_lock);
|
|
|
|
gpc->kvm = kvm;
|
|
gpc->vcpu = vcpu;
|
|
gpc->usage = usage;
|
|
gpc->pfn = KVM_PFN_ERR_FAULT;
|
|
gpc->uhva = KVM_HVA_ERR_BAD;
|
|
}
|
|
EXPORT_SYMBOL_GPL(kvm_gpc_init);
|
|
|
|
int kvm_gpc_activate(struct gfn_to_pfn_cache *gpc, gpa_t gpa, unsigned long len)
|
|
{
|
|
struct kvm *kvm = gpc->kvm;
|
|
|
|
if (!gpc->active) {
|
|
if (KVM_BUG_ON(gpc->valid, kvm))
|
|
return -EIO;
|
|
|
|
spin_lock(&kvm->gpc_lock);
|
|
list_add(&gpc->list, &kvm->gpc_list);
|
|
spin_unlock(&kvm->gpc_lock);
|
|
|
|
/*
|
|
* Activate the cache after adding it to the list, a concurrent
|
|
* refresh must not establish a mapping until the cache is
|
|
* reachable by mmu_notifier events.
|
|
*/
|
|
write_lock_irq(&gpc->lock);
|
|
gpc->active = true;
|
|
write_unlock_irq(&gpc->lock);
|
|
}
|
|
return __kvm_gpc_refresh(gpc, gpa, len);
|
|
}
|
|
EXPORT_SYMBOL_GPL(kvm_gpc_activate);
|
|
|
|
void kvm_gpc_deactivate(struct gfn_to_pfn_cache *gpc)
|
|
{
|
|
struct kvm *kvm = gpc->kvm;
|
|
kvm_pfn_t old_pfn;
|
|
void *old_khva;
|
|
|
|
if (gpc->active) {
|
|
/*
|
|
* Deactivate the cache before removing it from the list, KVM
|
|
* must stall mmu_notifier events until all users go away, i.e.
|
|
* until gpc->lock is dropped and refresh is guaranteed to fail.
|
|
*/
|
|
write_lock_irq(&gpc->lock);
|
|
gpc->active = false;
|
|
gpc->valid = false;
|
|
|
|
/*
|
|
* Leave the GPA => uHVA cache intact, it's protected by the
|
|
* memslot generation. The PFN lookup needs to be redone every
|
|
* time as mmu_notifier protection is lost when the cache is
|
|
* removed from the VM's gpc_list.
|
|
*/
|
|
old_khva = gpc->khva - offset_in_page(gpc->khva);
|
|
gpc->khva = NULL;
|
|
|
|
old_pfn = gpc->pfn;
|
|
gpc->pfn = KVM_PFN_ERR_FAULT;
|
|
write_unlock_irq(&gpc->lock);
|
|
|
|
spin_lock(&kvm->gpc_lock);
|
|
list_del(&gpc->list);
|
|
spin_unlock(&kvm->gpc_lock);
|
|
|
|
gpc_unmap_khva(old_pfn, old_khva);
|
|
}
|
|
}
|
|
EXPORT_SYMBOL_GPL(kvm_gpc_deactivate);
|