Skip to contentSkip to conversation

Fix the #PF injection logic for smaller MAXPHYADDR in nested.

PATCH In review Yu Zhang 2 participants 8 messages Jul 15, 2022 – Jul 19, 2022

Subsystems (3)
lore
Share & tools
lore

Yu Zhang

author
#0 lore raw

cover Fix the #PF injection logic for smaller MAXPHYADDR in nested.

KVM shall inject the #PF directly to L2 when L2 has a smaller MAXPHYADDR and L1 has no desire to intercept it, yet currently the #PF will be delivered to L1 anyway.

Patch 1 fixes this, by initializing the 'fault' variable. Patch 2 is just a cleanup for the comments.

Yu Zhang (2):
KVM: X86: Initialize 'fault' in kvm_fixup_and_inject_pf_error().
KVM: X86: Fix the comments in prepare_vmcs02_rare()

 arch/x86/kvm/vmx/nested.c | 8 ++++----
 arch/x86/kvm/x86.c        | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)
Signature · 1 line
2.25.1
author
#1 lore raw

PATCH 1/2 KVM: X86: Initialize 'fault' in kvm_fixup_and_inject_pf_error().

kvm_fixup_and_inject_pf_error() was introduced to fixup the error code( e.g., to add RSVD flag) and inject the #PF to the guest, when guest MAXPHYADDR is smaller than the host one.

When it comes to nested, L0 is expected to intercept and fix up the #PF and then inject to L2 directly if
- L2.MAXPHYADDR < L0.MAXPHYADDR and
- L1 has no intention to intercept L2's #PF (e.g., L2 and L1 have the same MAXPHYADDR value && L1 is using EPT for L2),
instead of constructing a #PF VM Exit to L1. Currently, with PFEC_MASK and PFEC_MATCH both set to 0 in vmcs02, the interception and injection may happen on all L2 #PFs.

However, failing to initialize 'fault' in kvm_fixup_and_inject_pf_error() may cause the fault.async_page_fault being NOT zeroed, and later the #PF being treated as a nested async page fault, and then being injected to L1. So just fix it by initialize the 'fault' value in the beginning.

Fixes 897861479c064 ("KVM: x86: Add helper functions for illegal GPA checking and page fault injection")

Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=216178

---
 arch/x86/kvm/x86.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
arch/x86/kvm/x86.c +1 -1
index 031678eff28e..3246b3c9dfb3 100644
@@ -12983,7 +12983,7 @@ EXPORT_SYMBOL_GPL(kvm_spec_ctrl_test_value);
 void kvm_fixup_and_inject_pf_error(struct kvm_vcpu *vcpu, gva_t gva, u16 error_code)
 {
 	struct kvm_mmu *mmu = vcpu->arch.walk_mmu;
-	struct x86_exception fault;
+	struct x86_exception fault = {0};
 	u64 access = error_code &
 		(PFERR_WRITE_MASK | PFERR_FETCH_MASK | PFERR_USER_MASK);
 
Signature · 1 line
2.25.1
#2 lore raw

Re: [PATCH 1/2] KVM: X86: Initialize 'fault' in kvm_fixup_and_inject_pf_error().

Quoted 13 lines · Yu Zhang

kvm_fixup_and_inject_pf_error() was introduced to fixup the error code( e.g., to add RSVD flag) and inject the #PF to the guest, when guest MAXPHYADDR is smaller than the host one.

When it comes to nested, L0 is expected to intercept and fix up the #PF and then inject to L2 directly if
- L2.MAXPHYADDR < L0.MAXPHYADDR and
- L1 has no intention to intercept L2's #PF (e.g., L2 and L1 have the same MAXPHYADDR value && L1 is using EPT for L2),
instead of constructing a #PF VM Exit to L1. Currently, with PFEC_MASK and PFEC_MATCH both set to 0 in vmcs02, the interception and injection may happen on all L2 #PFs.

Quoted 4 lines

However, failing to initialize 'fault' in kvm_fixup_and_inject_pf_error() may cause the fault.async_page_fault being NOT zeroed, and later the #PF being treated as a nested async page fault, and then being injected to L1. So just fix it by initialize the 'fault' value in the beginning.

Ouch.

Quoted 13 lines
Fixes 897861479c064 ("KVM: x86: Add helper functions for illegal GPA checking and page fault injection")

Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=216178

---
 arch/x86/kvm/x86.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
arch/x86/kvm/x86.c +0 -0
index 031678eff28e..3246b3c9dfb3 100644

arch/x86/kvm/x86.c EXPORT_SYMBOL_GPL(kvm_spec_ctrl_test_value); · line 12988

Quoted 7 lines
arch/x86/kvm/x86.c +1 -1
@@ -12983,7 +12983,7 @@ EXPORT_SYMBOL_GPL(kvm_spec_ctrl_test_value);
 void kvm_fixup_and_inject_pf_error(struct kvm_vcpu *vcpu, gva_t gva, u16 error_code)
 {
 	struct kvm_mmu *mmu = vcpu->arch.walk_mmu;
-	struct x86_exception fault;
+	struct x86_exception fault = {0};
 	u64 access = error_code &
 		(PFERR_WRITE_MASK | PFERR_FETCH_MASK | PFERR_USER_MASK);

As stupid as it may be to intentionally not fix the uninitialized data in a robust way, I'd actually prefer to manually clear fault.async_page_fault instead of zero-initializing the struct. Unlike a similar bug fix in commit 159e037d2e36 ("KVM: x86: Fully initialize 'struct kvm_lapic_irq' in kvm_pv_kick_cpu_op()"), this code actually cares about async_page_fault being false as opposed to just being _initialized_.

And if another field is added to struct x86_exception in the future, leaving the struct uninitialized means that if such a patch were to miss this case, running with various sanitizers should in theory be able to detect such a bug. I suspect no one has found this with syzkaller due to the need to opt into running with allow_smaller_maxphyaddr=1.

arch/x86/kvm/x86.c +1 -0
index f389691d8c04..aeed737b55c2 100644
@@ -12996,6 +12996,7 @@ void kvm_fixup_and_inject_pf_error(struct kvm_vcpu *vcpu, gva_t gva, u16 error_c
                fault.error_code = error_code;
                fault.nested_page_fault = false;
                fault.address = gva;
+               fault.async_page_fault = false;
        }
        vcpu->arch.walk_mmu->inject_page_fault(vcpu, &fault);
 }
author
#3 lore raw

Re: [PATCH 1/2] KVM: X86: Initialize 'fault' in kvm_fixup_and_inject_pf_error().

Quoted 61 lines · Sean Christopherson
Quoted 13 lines · Yu Zhang

kvm_fixup_and_inject_pf_error() was introduced to fixup the error code( e.g., to add RSVD flag) and inject the #PF to the guest, when guest MAXPHYADDR is smaller than the host one.

When it comes to nested, L0 is expected to intercept and fix up the #PF and then inject to L2 directly if
- L2.MAXPHYADDR < L0.MAXPHYADDR and
- L1 has no intention to intercept L2's #PF (e.g., L2 and L1 have the same MAXPHYADDR value && L1 is using EPT for L2),
instead of constructing a #PF VM Exit to L1. Currently, with PFEC_MASK and PFEC_MATCH both set to 0 in vmcs02, the interception and injection may happen on all L2 #PFs.

Quoted 4 lines

However, failing to initialize 'fault' in kvm_fixup_and_inject_pf_error() may cause the fault.async_page_fault being NOT zeroed, and later the #PF being treated as a nested async page fault, and then being injected to L1. So just fix it by initialize the 'fault' value in the beginning.

Ouch.

Quoted 13 lines
Fixes 897861479c064 ("KVM: x86: Add helper functions for illegal GPA checking and page fault injection")

Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=216178

---
 arch/x86/kvm/x86.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
arch/x86/kvm/x86.c +0 -0
index 031678eff28e..3246b3c9dfb3 100644

arch/x86/kvm/x86.c EXPORT_SYMBOL_GPL(kvm_spec_ctrl_test_value); · line 12988

Quoted 7 lines
arch/x86/kvm/x86.c +1 -1
@@ -12983,7 +12983,7 @@ EXPORT_SYMBOL_GPL(kvm_spec_ctrl_test_value);
 void kvm_fixup_and_inject_pf_error(struct kvm_vcpu *vcpu, gva_t gva, u16 error_code)
 {
 	struct kvm_mmu *mmu = vcpu->arch.walk_mmu;
-	struct x86_exception fault;
+	struct x86_exception fault = {0};
 	u64 access = error_code &
 		(PFERR_WRITE_MASK | PFERR_FETCH_MASK | PFERR_USER_MASK);

As stupid as it may be to intentionally not fix the uninitialized data in a robust way, I'd actually prefer to manually clear fault.async_page_fault instead of zero-initializing the struct. Unlike a similar bug fix in commit 159e037d2e36 ("KVM: x86: Fully initialize 'struct kvm_lapic_irq' in kvm_pv_kick_cpu_op()"), this code actually cares about async_page_fault being false as opposed to just being _initialized_.

And if another field is added to struct x86_exception in the future, leaving the struct uninitialized means that if such a patch were to miss this case, running with various sanitizers should in theory be able to detect such a bug. I suspect no one has found this with syzkaller due to the need to opt into running with allow_smaller_maxphyaddr=1.

arch/x86/kvm/x86.c +0 -0
index f389691d8c04..aeed737b55c2 100644

arch/x86/kvm/x86.c void kvm_fixup_and_inject_pf_error(struct kvm_vcpu *vcpu, gva_t gva, u16 error_c · line 13002

Quoted 7 lines
arch/x86/kvm/x86.c +1 -0
@@ -12996,6 +12996,7 @@ void kvm_fixup_and_inject_pf_error(struct kvm_vcpu *vcpu, gva_t gva, u16 error_c
                fault.error_code = error_code;
                fault.nested_page_fault = false;
                fault.address = gva;
+               fault.async_page_fault = false;
        }
        vcpu->arch.walk_mmu->inject_page_fault(vcpu, &fault);
 }

Fair enough. Thanks!

B.R.
Yu

author
#4 lore raw

PATCH 2/2 KVM: X86: Fix the comments in prepare_vmcs02_rare()

In reply to Yu Zhang

Although EB.PF in vmcs02 is still set by simply "or"ing the EB of vmcs01 and vmcs12, the explanation is obsolete. "enable_ept" being set is not the only reason for L0 to clear its EB.PF.

---
 arch/x86/kvm/vmx/nested.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
arch/x86/kvm/vmx/nested.c +4 -4
index 778f82015f03..634a7d218048 100644
@@ -2451,10 +2451,10 @@ static void prepare_vmcs02_rare(struct vcpu_vmx *vmx, struct vmcs12 *vmcs12)
 	 * is not easy (if at all possible?) to merge L0 and L1's desires, we
 	 * simply ask to exit on each and every L2 page fault. This is done by
 	 * setting MASK=MATCH=0 and (see below) EB.PF=1.
-	 * Note that below we don't need special code to set EB.PF beyond the
-	 * "or"ing of the EB of vmcs01 and vmcs12, because when enable_ept,
-	 * vmcs01's EB.PF is 0 so the "or" will take vmcs12's value, and when
-	 * !enable_ept, EB.PF is 1, so the "or" will always be 1.
+	 * Note that EB.PF is set by "or"ing of the EB of vmcs01 and vmcs12,
+	 * because when L0 has no desire to intercept #PF, vmcs01's EB.PF is 0
+	 * so the "or" will take vmcs12's value, otherwise EB.PF is 1, so the
+	 * "or" will always be 1.
 	 */
 	if (vmx_need_pf_intercept(&vmx->vcpu)) {
 		/*
Signature · 1 line
2.25.1
#5 lore raw

Re: [PATCH 2/2] KVM: X86: Fix the comments in prepare_vmcs02_rare()

Quoted 15 lines · Yu Zhang

Although EB.PF in vmcs02 is still set by simply "or"ing the EB of vmcs01 and vmcs12, the explanation is obsolete. "enable_ept" being set is not the only reason for L0 to clear its EB.PF.

---
 arch/x86/kvm/vmx/nested.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
arch/x86/kvm/vmx/nested.c +0 -0
index 778f82015f03..634a7d218048 100644
@@ -2451,10 +2451,10 @@ static void prepare_vmcs02_rare(struct vcpu_vmx *vmx, struct vmcs12 *vmcs12)
 	 * is not easy (if at all possible?) to merge L0 and L1's desires, we

arch/x86/kvm/vmx/nested.c static void prepare_vmcs02_rare(struct vcpu_vmx *vmx, struct vmcs12 *vmcs12) · line 2457

Quoted 10 lines
arch/x86/kvm/vmx/nested.c +4 -4
 	 * simply ask to exit on each and every L2 page fault. This is done by
 	 * setting MASK=MATCH=0 and (see below) EB.PF=1.
-	 * Note that below we don't need special code to set EB.PF beyond the
-	 * "or"ing of the EB of vmcs01 and vmcs12, because when enable_ept,
-	 * vmcs01's EB.PF is 0 so the "or" will take vmcs12's value, and when
-	 * !enable_ept, EB.PF is 1, so the "or" will always be 1.
+	 * Note that EB.PF is set by "or"ing of the EB of vmcs01 and vmcs12,
+	 * because when L0 has no desire to intercept #PF, vmcs01's EB.PF is 0
+	 * so the "or" will take vmcs12's value, otherwise EB.PF is 1, so the
+	 * "or" will always be 1.

Oof! I was going to respond with a variety of nits (about the existing comment), and even suggest that we address the TODO just out of sight, but looking at all of this made me realize there's a bug here! vmx_update_exception_bitmap() doesn't update MASK and MATCH!

Hitting the bug is extremely unlikely, as it would require changing the guest's MAXPHYADDR via KVM_SET_CPUID2 _after_ KVM_SET_NESTED_STATE, but before KVM_RUN (because KVM now disallows changin CPUID after KVM_RUN).

During KVM_SET_CPUID2, KVM will invoke vmx_update_exception_bitmap() to refresh the exception bitmap to handle the ept=1 && allow_smaller_maxphyaddr=1 scenario. But when L2 is active, vmx_update_exception_bitmap() assumes vmcs02 already has the correct MASK+MATCH because of the "clear both if KVM and L1 both want #PF" behavior. But if KVM's desire to intercept #PF changes from 0=>1, then KVM will run L2 with the MASK+MATCH from vmcs12 because vmx_need_pf_intercept() would have returned false at the time of prepare_vmcs02_rare().

Fixing the bug is fairly straightforward, and presents a good opportunity to clean up the code (and this comment) and address the TODO.

Unless someone objects to my suggestion for patch 01, can you send a new version of patch 01? I'll send a separate series to fix this theoretical bug, avoid writing MASK+MATCH when vmcs0x.EXCEPTION_BITMAP.PF+0, and to address the TODO.

E.g. I believe this is what we want to end up with:

	if (vmcs12)
		eb |= vmcs12->exception_bitmap;

	/*
	 * #PF is conditionally intercepted based on the #PF error code (PFEC)
	 * combined with the exception bitmap.  #PF is intercept if:
	 *
	 *    EXCEPTION_BITMAP.PF=1 && ((PFEC & MASK) == MATCH).
	 *
	 * If any #PF is being intercepted, update MASK+MATCH, otherwise leave
	 * them alone they do not affect interception (EXCEPTION_BITMAP.PF=0).
	 */
	if (eb & (1u << PF_VECTOR)) {
		/*
		 * If EPT is enabled, #PF is only intercepted if MAXPHYADDR is
		 * smaller on the guest than on the host.  In that case, KVM
		 * only needs to intercept present, non-reserved #PF.  If EPT
		 * is disabled, i.e. KVM is using shadow paging, KVM needs to
		 * intercept all #PF.  Note, whether or not KVM wants to
		 * intercept _any_ #PF is handled below.
		 */
		if (enable_ept) {
			pfec_mask = PFERR_PRESENT_MASK | PFERR_RSVD_MASK;
			pfec_match = PFERR_PRESENT_MASK;
		} else {
			pfec_mask = 0;
			pfec_match = 0;
		}

		if (!(vmcs12->exception_bitmap & (1u << PF_VECTOR))) {
			/* L1 doesn't want to intercept #PF, use KVM's MASK+MATCH. */
		} else if (!kvm_needs_pf_intercept) {
			/* KVM doesn't want to intercept #PF, use L1's MASK+MATCH. */
			pfec_mask = vmcs12->page_fault_error_code_mask;
			pfec_match = vmcs12->page_fault_error_code_match;
		} else if (pfec_mask != vmcs12->page_fault_error_code_mask ||
			   pfec_match != vmcs12->page_fault_error_code_mask) {
			/*
			 * KVM and L1 want to intercept #PF with different MASK
			 * and/or MATCH.  For simplicity, intercept all #PF by
			 * clearing MASK+MATCH.  Merging KVM's and L1's desires
			 * is quite complex, while the odds of meaningfully
			 * reducing what #PFs are intercept are low.
			 */
			pfec_mask = 0;
			pfec_match = 0;
		} else {
			/* KVM and L1 have identical MASK+MATCH. */
		}
		vmcs_write32(PAGE_FAULT_ERROR_CODE_MASK, pfec_mask);
		vmcs_write32(PAGE_FAULT_ERROR_CODE_MATCH, pfec_match);
	}
author
#6 lore raw

Re: [PATCH 2/2] KVM: X86: Fix the comments in prepare_vmcs02_rare()

Quoted 36 lines · Sean Christopherson
Quoted 15 lines · Yu Zhang

Although EB.PF in vmcs02 is still set by simply "or"ing the EB of vmcs01 and vmcs12, the explanation is obsolete. "enable_ept" being set is not the only reason for L0 to clear its EB.PF.

---
 arch/x86/kvm/vmx/nested.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
arch/x86/kvm/vmx/nested.c +0 -0
index 778f82015f03..634a7d218048 100644
@@ -2451,10 +2451,10 @@ static void prepare_vmcs02_rare(struct vcpu_vmx *vmx, struct vmcs12 *vmcs12)
 	 * is not easy (if at all possible?) to merge L0 and L1's desires, we

arch/x86/kvm/vmx/nested.c static void prepare_vmcs02_rare(struct vcpu_vmx *vmx, struct vmcs12 *vmcs12) · line 2457

Quoted 10 lines
arch/x86/kvm/vmx/nested.c +4 -4
 	 * simply ask to exit on each and every L2 page fault. This is done by
 	 * setting MASK=MATCH=0 and (see below) EB.PF=1.
-	 * Note that below we don't need special code to set EB.PF beyond the
-	 * "or"ing of the EB of vmcs01 and vmcs12, because when enable_ept,
-	 * vmcs01's EB.PF is 0 so the "or" will take vmcs12's value, and when
-	 * !enable_ept, EB.PF is 1, so the "or" will always be 1.
+	 * Note that EB.PF is set by "or"ing of the EB of vmcs01 and vmcs12,
+	 * because when L0 has no desire to intercept #PF, vmcs01's EB.PF is 0
+	 * so the "or" will take vmcs12's value, otherwise EB.PF is 1, so the
+	 * "or" will always be 1.

Oof! I was going to respond with a variety of nits (about the existing comment), and even suggest that we address the TODO just out of sight, but looking at all of this made me realize there's a bug here! vmx_update_exception_bitmap() doesn't update MASK and MATCH!

Hitting the bug is extremely unlikely, as it would require changing the guest's MAXPHYADDR via KVM_SET_CPUID2 _after_ KVM_SET_NESTED_STATE, but before KVM_RUN (because KVM now disallows changin CPUID after KVM_RUN).

Quoted 7 lines

During KVM_SET_CPUID2, KVM will invoke vmx_update_exception_bitmap() to refresh the exception bitmap to handle the ept=1 && allow_smaller_maxphyaddr=1 scenario. But when L2 is active, vmx_update_exception_bitmap() assumes vmcs02 already has the correct MASK+MATCH because of the "clear both if KVM and L1 both want #PF" behavior. But if KVM's desire to intercept #PF changes from 0=>1, then KVM will run L2 with the MASK+MATCH from vmcs12 because vmx_need_pf_intercept() would have returned false at the time of prepare_vmcs02_rare().

And then the #PF could be missed in L0 because previously both L1 and L0 has no desire to intercept it, meanwhile KVM fails to update this after migration(I guess the only scenario for this to happen is migration?). Is this understanding correct?

Quoted 7 lines

Fixing the bug is fairly straightforward, and presents a good opportunity to clean up the code (and this comment) and address the TODO.

Unless someone objects to my suggestion for patch 01, can you send a new version of patch 01? I'll send a separate series to fix this theoretical bug, avoid writing MASK+MATCH when vmcs0x.EXCEPTION_BITMAP.PF+0, and to address the TODO.

Sure, I will send another version of patch 01.

Quoted 47 lines

E.g. I believe this is what we want to end up with:

	if (vmcs12)
		eb |= vmcs12->exception_bitmap;

	/*
	 * #PF is conditionally intercepted based on the #PF error code (PFEC)
	 * combined with the exception bitmap.  #PF is intercept if:
	 *
	 *    EXCEPTION_BITMAP.PF=1 && ((PFEC & MASK) == MATCH).
	 *
	 * If any #PF is being intercepted, update MASK+MATCH, otherwise leave
	 * them alone they do not affect interception (EXCEPTION_BITMAP.PF=0).
	 */
	if (eb & (1u << PF_VECTOR)) {
		/*
		 * If EPT is enabled, #PF is only intercepted if MAXPHYADDR is
		 * smaller on the guest than on the host.  In that case, KVM
		 * only needs to intercept present, non-reserved #PF.  If EPT
		 * is disabled, i.e. KVM is using shadow paging, KVM needs to
		 * intercept all #PF.  Note, whether or not KVM wants to
		 * intercept _any_ #PF is handled below.
		 */
		if (enable_ept) {
			pfec_mask = PFERR_PRESENT_MASK | PFERR_RSVD_MASK;
			pfec_match = PFERR_PRESENT_MASK;
		} else {
			pfec_mask = 0;
			pfec_match = 0;
		}

		if (!(vmcs12->exception_bitmap & (1u << PF_VECTOR))) {
			/* L1 doesn't want to intercept #PF, use KVM's MASK+MATCH. */
		} else if (!kvm_needs_pf_intercept) {
			/* KVM doesn't want to intercept #PF, use L1's MASK+MATCH. */
			pfec_mask = vmcs12->page_fault_error_code_mask;
			pfec_match = vmcs12->page_fault_error_code_match;
		} else if (pfec_mask != vmcs12->page_fault_error_code_mask ||
			   pfec_match != vmcs12->page_fault_error_code_mask) {
			/*
			 * KVM and L1 want to intercept #PF with different MASK
			 * and/or MATCH.  For simplicity, intercept all #PF by
			 * clearing MASK+MATCH.  Merging KVM's and L1's desires
			 * is quite complex, while the odds of meaningfully
			 * reducing what #PFs are intercept are low.
			 */
Quoted 8 lines
			pfec_mask = 0;
			pfec_match = 0;
		} else {
			/* KVM and L1 have identical MASK+MATCH. */
		}
		vmcs_write32(PAGE_FAULT_ERROR_CODE_MASK, pfec_mask);
		vmcs_write32(PAGE_FAULT_ERROR_CODE_MATCH, pfec_match);
	}

And we do not need to update the PFEC_MASK & PFEC_MATCH in prepare_vmcs02_rare() anymore, right? Thanks!

B.R.
Yu

#7 lore raw

Re: [PATCH 2/2] KVM: X86: Fix the comments in prepare_vmcs02_rare()

Quoted 19 lines · Yu Zhang
Quoted 10 lines · Sean Christopherson

On Fri, Jul 15, 2022, Yu Zhang wrote:
Oof! I was going to respond with a variety of nits (about the existing comment), and even suggest that we address the TODO just out of sight, but looking at all of this made me realize there's a bug here! vmx_update_exception_bitmap() doesn't update MASK and MATCH!

Hitting the bug is extremely unlikely, as it would require changing the guest's MAXPHYADDR via KVM_SET_CPUID2 _after_ KVM_SET_NESTED_STATE, but before KVM_RUN (because KVM now disallows changin CPUID after KVM_RUN).

Quoted 7 lines

During KVM_SET_CPUID2, KVM will invoke vmx_update_exception_bitmap() to refresh the exception bitmap to handle the ept=1 && allow_smaller_maxphyaddr=1 scenario. But when L2 is active, vmx_update_exception_bitmap() assumes vmcs02 already has the correct MASK+MATCH because of the "clear both if KVM and L1 both want #PF" behavior. But if KVM's desire to intercept #PF changes from 0=>1, then KVM will run L2 with the MASK+MATCH from vmcs12 because vmx_need_pf_intercept() would have returned false at the time of prepare_vmcs02_rare().

Quoted 3 lines

And then the #PF could be missed in L0 because previously both L1 and L0 has no desire to intercept it, meanwhile KVM fails to update this after migration(I guess the only scenario for this to happen is migration?). Is this understanding correct?

Yes, I think that will be the scenario (I hadn't thought too much about the actual result).

Quoted 65 lines
Quoted 6 lines

Fixing the bug is fairly straightforward, and presents a good opportunity to clean up the code (and this comment) and address the TODO.

Unless someone objects to my suggestion for patch 01, can you send a new version of patch 01? I'll send a separate series to fix this theoretical bug, avoid writing MASK+MATCH when vmcs0x.EXCEPTION_BITMAP.PF+0, and to address the TODO.

Sure, I will send another version of patch 01.

Quoted 47 lines

E.g. I believe this is what we want to end up with:

	if (vmcs12)
		eb |= vmcs12->exception_bitmap;

	/*
	 * #PF is conditionally intercepted based on the #PF error code (PFEC)
	 * combined with the exception bitmap.  #PF is intercept if:
	 *
	 *    EXCEPTION_BITMAP.PF=1 && ((PFEC & MASK) == MATCH).
	 *
	 * If any #PF is being intercepted, update MASK+MATCH, otherwise leave
	 * them alone they do not affect interception (EXCEPTION_BITMAP.PF=0).
	 */
	if (eb & (1u << PF_VECTOR)) {
		/*
		 * If EPT is enabled, #PF is only intercepted if MAXPHYADDR is
		 * smaller on the guest than on the host.  In that case, KVM
		 * only needs to intercept present, non-reserved #PF.  If EPT
		 * is disabled, i.e. KVM is using shadow paging, KVM needs to
		 * intercept all #PF.  Note, whether or not KVM wants to
		 * intercept _any_ #PF is handled below.
		 */
		if (enable_ept) {
			pfec_mask = PFERR_PRESENT_MASK | PFERR_RSVD_MASK;
			pfec_match = PFERR_PRESENT_MASK;
		} else {
			pfec_mask = 0;
			pfec_match = 0;
		}

		if (!(vmcs12->exception_bitmap & (1u << PF_VECTOR))) {
			/* L1 doesn't want to intercept #PF, use KVM's MASK+MATCH. */
		} else if (!kvm_needs_pf_intercept) {
			/* KVM doesn't want to intercept #PF, use L1's MASK+MATCH. */
			pfec_mask = vmcs12->page_fault_error_code_mask;
			pfec_match = vmcs12->page_fault_error_code_match;
		} else if (pfec_mask != vmcs12->page_fault_error_code_mask ||
			   pfec_match != vmcs12->page_fault_error_code_mask) {
			/*
			 * KVM and L1 want to intercept #PF with different MASK
			 * and/or MATCH.  For simplicity, intercept all #PF by
			 * clearing MASK+MATCH.  Merging KVM's and L1's desires
			 * is quite complex, while the odds of meaningfully
			 * reducing what #PFs are intercept are low.
			 */
Quoted 8 lines
			pfec_mask = 0;
			pfec_match = 0;
		} else {
			/* KVM and L1 have identical MASK+MATCH. */
		}
		vmcs_write32(PAGE_FAULT_ERROR_CODE_MASK, pfec_mask);
		vmcs_write32(PAGE_FAULT_ERROR_CODE_MATCH, pfec_match);
	}
Quoted 2 lines

And we do not need to update the PFEC_MASK & PFEC_MATCH in prepare_vmcs02_rare() anymore, right? Thanks!

Yep!

Also, IIRC I have a goof or two in the above, i.e. don't waste any time trying to test it.