KVM: nVMX: Reject nested VM-entry in wait-for-SIPI with a pending event injection
PATCH 1/1 KVM: nVMX: Reject nested VM-entry in wait-for-SIPI with a pending event injection
nested_check_guest_non_reg_state() only verifies that guest_activity_state is one of ACTIVE, HLT or WAIT_SIPI; it performs none of the activity-state cross-checks that VM entry requires. Per Intel's SDM, "Checks on Guest Non-Register State", when the valid bit of the VM-entry interruption-information field is set the interruption to be delivered "must not be one that would normally be blocked while a logical processor is in the activity state", and for the wait-for-SIPI state "No interruptions are allowed". The same section also requires that the activity state indicate the active state when the interruptibility-state field blocks by STI or MOV SS.
KVM accepts a vmcs12 that violates both rules, and hardware does not catch the miss: prepare_vmcs02() never writes GUEST_ACTIVITY_STATE, so vmcs02 always carries active, and wait-for-SIPI is emulated in software only after a successful entry (the mp_state = INIT_RECEIVED arm). The injection, in contrast, is copied into vmcs02. The physical VMLAUNCH therefore sees {active, valid injection} -- a legal pair -- and succeeds. Because the offending field is stripped before hardware sees vmcs02, the missed-exit WARN in __nested_vmx_vmexit() can never fire for this class either.
From L1's point of view a VMLAUNCH that bare metal rejects with a VM-entry failure (invalid guest state) instead succeeds, with L2 left parked in wait-for-SIPI holding a stale VM_ENTRY_INTR_INFO in vmcs02.
Add the two activity-state cross-checks that KVM strips before hardware can enforce them. The HLT state additionally restricts which interruption types may be injected (external interrupt / NMI / #DB / #MC / pending-MTF only); that matrix is left for a follow-up as it needs the per-type table, whereas the two checks added here are unconditional and cover the fields KVM elides.
--- arch/x86/kvm/vmx/nested.c | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+)
arch/x86/kvm/vmx/nested.c +17 -0
@@ -3311,6 +3311,24 @@ static int nested_check_guest_non_reg_state(struct vmcs12 *vmcs12) vmcs12->guest_activity_state != GUEST_ACTIVITY_WAIT_SIPI)) return -EINVAL; +/* +* The activity state must be active if the interruptibility state +* blocks by STI or MOV SS. +*/ + if (CC(vmcs12->guest_activity_state != GUEST_ACTIVITY_ACTIVE && + (vmcs12->guest_interruptibility_info & + (GUEST_INTR_STATE_STI |GUEST_INTR_STATE_MOV_SS )))) + return -EINVAL; + +/* +* An injected event must not be one that would be blocked in the +* guest's activity state; no interruptions are allowed in the +* wait-for-SIPI state. +*/ +if (vmcs12->guest_activity_state ==GUEST_ACTIVITY_WAIT_SIPI && +CC (vmcs12->vm_entry_intr_info_field &INTR_INFO_VALID_MASK )) +return -EINVAL ; +return 0 ; } -- 2.54.0 (Apple Git-157)
Sean Christopherson
maintainerQuoted 21 lines · Amirmohammad Eftekhar
nested_check_guest_non_reg_state()only verifies thatguest_activity_stateis one of ACTIVE, HLT orWAIT_SIPI; it performs none of the activity-state cross-checks that VM entry requires. Per Intel's SDM, "Checks on Guest Non-Register State", when the valid bit of the VM-entry interruption-information field is set the interruption to be delivered "must not be one that would normally be blocked while a logical processor is in the activity state", and for the wait-for-SIPI state "No interruptions are allowed". The same section also requires that the activity state indicate the active state when the interruptibility-state field blocks by STI or MOV SS.KVM accepts a vmcs12 that violates both rules, and hardware does not catch the miss:
prepare_vmcs02()never writesGUEST_ACTIVITY_STATE, so vmcs02 always carries active, and wait-for-SIPI is emulated in software only after a successful entry (themp_state=INIT_RECEIVEDarm). The injection, in contrast, is copied into vmcs02. The physical VMLAUNCH therefore sees {active, valid injection} -- a legal pair -- and succeeds. Because the offending field is stripped before hardware sees vmcs02, the missed-exit WARN in__nested_vmx_vmexit()can never fire for this class either.
Quoted 6 lines
From L1's point of view a VMLAUNCH that bare metal rejects with a VM-entry failure (invalid guest state) instead succeeds, with L2 left parked in wait-for-SIPI holding a stale
VM_ENTRY_INTR_INFOin vmcs02.Add the two activity-state cross-checks that KVM strips before hardware can enforce them.
Please split this into two patches, one for each consistency check. The justification for why KVM needs these checks is the same, but the changes themselves are independent.
Quoted 16 lines
The HLT state additionally restricts which
interruption types may be injected (external interrupt / NMI / #DB / #MC / pending-MTF only); that matrix is left for a follow-up as it needs the per-type table, whereas the two checks added here are unconditional and cover the fields KVM elides.Signed-off-by Amirmohammad Eftekhar <[email protected]>--- arch/x86/kvm/vmx/nested.c | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+)arch/x86/kvm/vmx/nested.c +0
-0
arch/x86/kvm/vmx/nested.c static int nested_check_guest_non_reg_state(struct · line 3317
Quoted 7 lines
arch/x86/kvm/vmx/nested.c +3
-0@@ -3311,6 +3311,24 @@ static int nested_check_guest_non_reg_state(struct vmcs12 *vmcs12) vmcs12->guest_activity_state != GUEST_ACTIVITY_WAIT_SIPI)) return -EINVAL; + /* +* The activity state must be active if the interruptibility state +* blocks by STI or MOV SS. +*/
Eh, drop this comment, it's pretty much just restating the code verbatim.
arch/x86/kvm/vmx/nested.c static int nested_check_guest_non_reg_state(struct vmcs12 *vmcs12) · line 3326
Quoted 10 lines
arch/x86/kvm/vmx/nested.c +10
-0+if (CC (vmcs12->guest_activity_state !=GUEST_ACTIVITY_ACTIVE && + (vmcs12->guest_interruptibility_info & + (GUEST_INTR_STATE_STI |GUEST_INTR_STATE_MOV_SS )))) +return -EINVAL ; + +/* +* An injected event must not be one that would be blocked in the +* guest's activity state; no interruptions are allowed in the +* wait-for-SIPI state. +*/
I think a TODO would be helpful. Actually, what if we structure the entire function as a switch-statement? Gah, never mind, the check on MOV-SS and STI blocking makes that annoying to deal with.
Anyways, how about this?
/* * Injected events are disallowed if they are blocked by the activity * state. All injectable events are allowed in the active state, all * are blocked by Wait-For-SIPI, and a small subset are allowed for HLT. * * TODO: Add consistency checks for HLT with an injected event. */ if (CC(vmcs12->guest_activity_state == GUEST_ACTIVITY_WAIT_SIPI && vmcs12->vm_entry_intr_info_field & INTR_INFO_VALID_MASK)) return -EINVAL;
arch/x86/kvm/vmx/nested.c static int nested_check_guest_non_reg_state(struct vmcs12 *vmcs12) · line 3328
Quoted 2 lines
arch/x86/kvm/vmx/nested.c +2
-0+if (vmcs12->guest_activity_state ==GUEST_ACTIVITY_WAIT_SIPI && +CC (vmcs12->vm_entry_intr_info_field &INTR_INFO_VALID_MASK ))
Put the whole if-statement in the CC(), otherwise the error that shows up in the trace will just be "vmcs12->vm_entry_intr_info_field & INTR_INFO_VALID_MASK" without any context.
Quoted 6 lines
arch/x86/kvm/vmx/nested.c +2
-0+return -EINVAL ; +return 0 ; } -- 2.54.0 (Apple Git-157)
v3 cover KVM: nVMX: Add the activity-state cross-checks VM-entry requires
From: Amirmohammad Eftekhar <[email protected]>
nested_check_guest_non_reg_state() only verifies that guest_activity_state is one of ACTIVE/HLT/WAIT_SIPI; it performs none of the activity-state cross-checks that VM entry requires. Per Intel's SDM, "Checks on Guest Non-Register State":
the activity state must indicate the active state when the interruptibility-state field blocks by STI or MOV SS, and when the valid bit of the VM-entry interruption-information field is set the interruption "must not be one that would normally be blocked" in the activity state -- for wait-for-SIPI, "No interruptions are allowed".
KVM cannot rely on hardware to catch either miss: prepare_vmcs02() never writes GUEST_ACTIVITY_STATE, so vmcs02 always carries the active state while the injection is copied into vmcs02, and the physical VMLAUNCH sees a legal pair and succeeds. The missed-exit WARN in __nested_vmx_vmexit() cannot fire for this class either, since the offending field is stripped before hardware sees vmcs02.
The two checks share this justification but are independent changes, so they are split into separate patches per review feedback.
v3:
- split into two patches, one per consistency check (Sean)
- drop the comment that merely restated the code (Sean)
v2: clean resend of v1 (v1 was whitespace-damaged in transit by a mail client).
Amirmohammad Eftekhar (2):
KVM: nVMX: Reject nested VM-entry in a non-active state blocked by
STI/MOV-SS
KVM: nVMX: Reject nested VM-entry in wait-for-SIPI with a pending
event injection
arch/x86/kvm/vmx/nested.c | 9 +++++++++ 1 file changed, 9 insertions(+)
Signature · 1 line
2.34.1
PATCH v3 1/2 KVM: nVMX: Reject nested VM-entry in a non-active state blocked by STI/MOV-SS
In reply to Sean ChristophersonFrom: Amirmohammad Eftekhar <[email protected]>
nested_check_guest_non_reg_state() only checks that guest_activity_state is one of ACTIVE/HLT/WAIT_SIPI; it does not enforce the SDM's requirement that the activity state indicate the active state when the interruptibility-state field blocks by STI or MOV SS. KVM cannot rely on hardware to catch the
miss: prepare_vmcs02() never writes GUEST_ACTIVITY_STATE, so vmcs02 always carries the active state and the physical VMLAUNCH cannot reject the illegal combination. Add the cross-check.
--- arch/x86/kvm/vmx/nested.c | 5 +++++ 1 file changed, 5 insertions(+)
arch/x86/kvm/vmx/nested.c +5 -0
@@ -3311,6 +3311,11 @@ static int nested_check_guest_non_reg_state(struct vmcs12 *vmcs12) vmcs12->guest_activity_state != GUEST_ACTIVITY_WAIT_SIPI)) return -EINVAL; +if (CC (vmcs12->guest_activity_state !=GUEST_ACTIVITY_ACTIVE && + (vmcs12->guest_interruptibility_info & + (GUEST_INTR_STATE_STI |GUEST_INTR_STATE_MOV_SS )))) +return -EINVAL ; +return 0 ; }
Signature · 1 line
2.34.1
PATCH v3 2/2 KVM: nVMX: Reject nested VM-entry in wait-for-SIPI with a pending event injection
In reply to Sean ChristophersonFrom: Amirmohammad Eftekhar <[email protected]>
The SDM allows no interruptions in the wait-for-SIPI activity state, but nested_check_guest_non_reg_state() accepts a vmcs12 with WAIT_SIPI and a valid VM-entry interruption-information field. Hardware does not catch it: KVM emulates wait-for-SIPI in software only after a successful entry (the mp_state = INIT_RECEIVED arm) while the injection is copied into vmcs02, so the physical VMLAUNCH sees {active, valid injection} -- a legal pair -- and succeeds. From L1's point of view a VMLAUNCH that bare metal rejects with a VM-entry failure instead succeeds, with L2 parked in wait-for-SIPI holding a stale VM_ENTRY_INTR_INFO. Reject the combination.
--- arch/x86/kvm/vmx/nested.c | 4 ++++ 1 file changed, 4 insertions(+)
arch/x86/kvm/vmx/nested.c +4 -0
@@ -3316,6 +3316,10 @@ static int nested_check_guest_non_reg_state(struct vmcs12 *vmcs12) (GUEST_INTR_STATE_STI | GUEST_INTR_STATE_MOV_SS)))) return -EINVAL; +if (vmcs12->guest_activity_state ==GUEST_ACTIVITY_WAIT_SIPI && +CC (vmcs12->vm_entry_intr_info_field &INTR_INFO_VALID_MASK )) +return -EINVAL ; +return 0 ; }
Signature · 1 line
2.34.1