virt/kvm/pfncache.c - linux - Git at Google

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