Commit 2c3412e9 authored by Rick Edgecombe's avatar Rick Edgecombe Committed by Paolo Bonzini
Browse files

KVM: x86/mmu: Prevent aliased memslot GFNs 

Add a few sanity checks to prevent memslot GFNs from ever having alias bits
set.

Like other Coco technologies, TDX has the concept of private and shared
memory. For TDX the private and shared mappings are managed on separate
EPT roots. The private half is managed indirectly though calls into a
protected runtime environment called the TDX module, where the shared half
is managed within KVM in normal page tables.

For TDX, the shared half will be mapped in the higher alias, with a "shared
bit" set in the GPA. However, KVM will still manage it with the same
memslots as the private half. This means memslot looks ups and zapping
operations will be provided with a GFN without the shared bit set.

If these memslot GFNs ever had the bit that selects between the two aliases
it could lead to unexpected behavior in the complicated code that directs
faulting or zapping operations between the roots that map the two aliases.

As a safety measure, prevent memslots from being set at a GFN range that
contains the alias bit.

Also, check in the kvm_faultin_pfn() for the fault path. This later check
does less today, as the alias bits are specifically stripped from the GFN
being checked, however future code could possibly call in to the fault
handler in a way that skips this stripping. Since kvm_faultin_pfn() now
has many references to vcpu->kvm, extract it to local variable.

Link: https://lore.kernel.org/kvm/ZpbKqG_ZhCWxl-Fc@google.com/


Suggested-by: default avatarSean Christopherson <seanjc@google.com>
Signed-off-by: default avatarRick Edgecombe <rick.p.edgecombe@intel.com>
Message-ID: <20240718211230.1492011-19-rick.p.edgecombe@intel.com>
Signed-off-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
parent df4af9f8

arch/x86/kvm/mmu.h

+5 −0
Original line number Diff line number Diff line
@@ -313,4 +313,9 @@ static inline bool kvm_is_addr_direct(struct kvm *kvm, gpa_t gpa) 


	return !gpa_direct_bits || (gpa & gpa_direct_bits);

}



static inline bool kvm_is_gfn_alias(struct kvm *kvm, gfn_t gfn)

{

	return gfn & kvm_gfn_direct_bits(kvm);

}

#endif

arch/x86/kvm/mmu/mmu.c

+7 −3
Original line number Diff line number Diff line
@@ -4391,8 +4391,12 @@ static int kvm_mmu_faultin_pfn(struct kvm_vcpu *vcpu, 
			       struct kvm_page_fault *fault, unsigned int access)

{

	struct kvm_memory_slot *slot = fault->slot;

	struct kvm *kvm = vcpu->kvm;

	int ret;



	if (KVM_BUG_ON(kvm_is_gfn_alias(kvm, fault->gfn), kvm))

		return -EFAULT;



	/*

	 * Note that the mmu_invalidate_seq also serves to detect a concurrent

	 * change in attributes.  is_page_fault_stale() will detect an
@@ -4406,7 +4410,7 @@ static int kvm_mmu_faultin_pfn(struct kvm_vcpu *vcpu, 
	 * Now that we have a snapshot of mmu_invalidate_seq we can check for a

	 * private vs. shared mismatch.

	 */

	if (fault->is_private != kvm_mem_is_private(vcpu->kvm, fault->gfn)) {

	if (fault->is_private != kvm_mem_is_private(kvm, fault->gfn)) {

		kvm_mmu_prepare_memory_fault_exit(vcpu, fault);

		return -EFAULT;

	}
@@ -4468,7 +4472,7 @@ static int kvm_mmu_faultin_pfn(struct kvm_vcpu *vcpu, 
	 * *guaranteed* to need to retry, i.e. waiting until mmu_lock is held

	 * to detect retry guarantees the worst case latency for the vCPU.

	 */

	if (mmu_invalidate_retry_gfn_unsafe(vcpu->kvm, fault->mmu_seq, fault->gfn))

	if (mmu_invalidate_retry_gfn_unsafe(kvm, fault->mmu_seq, fault->gfn))

		return RET_PF_RETRY;



	ret = __kvm_mmu_faultin_pfn(vcpu, fault);
@@ -4488,7 +4492,7 @@ static int kvm_mmu_faultin_pfn(struct kvm_vcpu *vcpu, 
	 * overall cost of failing to detect the invalidation until after

	 * mmu_lock is acquired.

	 */

	if (mmu_invalidate_retry_gfn_unsafe(vcpu->kvm, fault->mmu_seq, fault->gfn)) {

	if (mmu_invalidate_retry_gfn_unsafe(kvm, fault->mmu_seq, fault->gfn)) {

		kvm_mmu_finish_page_fault(vcpu, fault, RET_PF_RETRY);

		return RET_PF_RETRY;

	}

arch/x86/kvm/x86.c

+3 −0
Original line number Diff line number Diff line
@@ -13010,6 +13010,9 @@ int kvm_arch_prepare_memory_region(struct kvm *kvm, 
		if ((new->base_gfn + new->npages - 1) > kvm_mmu_max_gfn())

			return -EINVAL;



		if (kvm_is_gfn_alias(kvm, new->base_gfn + new->npages - 1))

			return -EINVAL;



		return kvm_alloc_memslot_metadata(kvm, new);

	}