| // 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); |