KVM: x86: AVIC and local APIC fixes+cleanups
Subsystems (4)
Sean Christopherson
maintainerv5 cover KVM: x86: AVIC and local APIC fixes+cleanups
Paolo,
This is a wholesale (and hopefully a drop-in) replacement for the patches in kvm-lapic-fix-and-cleanup. The changes for " KVM: x86: Inhibit APIC memslot if x2APIC and AVIC are enabled" in v5 are relatively minor, but it led to multiple conflicts in later patches, i.e. a patch-to-be-squashed wasn't going to work. Let me know if you've already done a lot of massaging on your side, shouldn't be too difficult to generate patches to go on top.
The first half or so patches fix semi-urgent, real-world relevant APICv and AVIC bugs.
The second half fixes a variety of AVIC and optimized APIC map bugs where KVM doesn't play nice with various edge cases that are architecturally legal(ish), but are unlikely to occur in most real world scenarios
v5:
- Fix even more bugs! [Greg]
- Collect reviews. [Maxim]
- Don't use an inhibit flag for hybrid AVIC. [Maxim]
- Fix an LDR cluster calc goof in the AVIC code. [Maxim]
- Drop a redundant "ldr == 0" check. [Maxim]
- Add helpers for logical vs. physical optimized map calcs. [Maxim]
v4:
- https://lore.kernel.org/all/[email protected]
- Fix more bugs! [Alejandro]
- Delete APIC memslot to inhibit xAVIC acceleration when x2APIC is enabled on AMD/SVM instead of using a "partial" inihbit. [Maxim]
v3:
- https://lore.kernel.org/all/[email protected]
- Collect reviews. [Paolo]
- Drop "partial" x2APIC inhibit and instead delete the memslot. [Maxim, Suravee]
- Skip logical mode updates for x2APIC, which just reuses the phys_map with some clever logic. [Suravee]
- Add a fix for "nodecode write" traps. [Alejandro]
v2:
- https://lore.kernel.org/all/[email protected]
- Collect reviews. [Li, Maxim]
- Disable only MMIO access when x2APIC is enabled (instead of disabling all of AVIC). [Maxim]
- Inhibit AVIC when logical IDs are aliased. [Maxim]
- Tweak name of set_virtual_apic_mode() hook. [Maxim]
- Straight up revert logical ID fastpath mess. [Maxim]
- Reword changelog about skipping vCPU during logical setup. [Maxim]
- Fix LDR updates on AVIC. [Maxim?]
- Fix a nasty ISR caching bug.
- Flush TLB when activating AVIC.
v1: https://lore.kernel.org/all/[email protected]
Greg Edwards (1):
KVM: x86: Allow APICv APIC ID inhibit to be cleared
Sean Christopherson (31):
KVM: x86: Blindly get current x2APIC reg value on "nodecode write"
traps
KVM: x86: Purge "highest ISR" cache when updating APICv state
KVM: SVM: Flush the "current" TLB when activating AVIC
KVM: SVM: Process ICR on AVIC IPI delivery failure due to invalid
target
KVM: x86: Don't inhibit APICv/AVIC on xAPIC ID "change" if APIC is
disabled
KVM: x86: Don't inhibit APICv/AVIC if xAPIC ID mismatch is due to
32-bit ID
KVM: SVM: Don't put/load AVIC when setting virtual APIC mode
KVM: x86: Handle APICv updates for APIC "mode" changes via request
KVM: x86: Move APIC access page helper to common x86 code
KVM: x86: Inhibit APIC memslot if x2APIC and AVIC are enabled
KVM: SVM: Replace "avic_mode" enum with "x2avic_enabled" boolean
KVM: SVM: Compute dest based on sender's x2APIC status for AVIC kick Revert "KVM: SVM: Use target APIC ID to complete x2AVIC IRQs when
possible"
KVM: SVM: Document that vCPU ID == APIC ID in AVIC kick fastpatch
KVM: SVM: Add helper to perform final AVIC "kick" of single vCPU
KVM: x86: Explicitly skip optimized logical map setup if vCPU's LDR==0
KVM: x86: Explicitly track all possibilities for APIC map's logical
modes
KVM: x86: Skip redundant x2APIC logical mode optimized cluster setup
KVM: x86: Disable APIC logical map if logical ID covers multiple MDAs
KVM: x86: Disable APIC logical map if vCPUs are aliased in logical
mode
KVM: x86: Honor architectural behavior for aliased 8-bit APIC IDs
KVM: x86: Inhibit APICv/AVIC if the optimized physical map is disabled
KVM: SVM: Inhibit AVIC if vCPUs are aliased in logical mode
KVM: SVM: Always update local APIC on writes to logical dest register
KVM: SVM: Update svm->ldr_reg cache even if LDR is "bad"
KVM: SVM: Require logical ID to be power-of-2 for AVIC entry
KVM: SVM: Handle multiple logical targets in AVIC kick fastpath
KVM: SVM: Ignore writes to Remote Read Data on AVIC write traps Revert "KVM: SVM: Do not throw warning when calling avic_vcpu_load on
a running vcpu"
KVM: x86: Track required APICv inhibits with variable, not callback
KVM: x86: Add helpers to recalc physical vs. logical optimized APIC
maps
Suravee Suthikulpanit (1):
KVM: SVM: Fix x2APIC Logical ID calculation for
avic_kick_target_vcpus_fast
Documentation/virt/kvm/x86/errata.rst | 11 + arch/x86/include/asm/kvm-x86-ops.h | 1 - arch/x86/include/asm/kvm_host.h | 52 +++- arch/x86/kvm/lapic.c | 319 +++++++++++++++++----- arch/x86/kvm/lapic.h | 2 + arch/x86/kvm/svm/avic.c | 372 ++++++++++++-------------- arch/x86/kvm/svm/nested.c | 2 +- arch/x86/kvm/svm/svm.c | 8 +- arch/x86/kvm/svm/svm.h | 27 +- arch/x86/kvm/vmx/vmx.c | 58 +--- arch/x86/kvm/x86.c | 29 +- 11 files changed, 524 insertions(+), 357 deletions(-)
base-commit: c04ec04c0d15a51aa33660be175ed978beb8de0c
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 1/33 KVM: x86: Blindly get current x2APIC reg value on "nodecode write" traps
When emulating a x2APIC write in response to an APICv/AVIC trap, get the the written value from the vAPIC page without checking that reads are allowed for the target register. AVIC can generate trap-like VM-Exits on writes to EOI, and so KVM needs to get the written value from the backing page without running afoul of EOI's write-only behavior.
Alternatively, EOI could be special cased to always write '0', e.g. so that the sanity check could be preserved, but x2APIC on AMD is actually supposed to disallow non-zero writes (not emulated by KVM), and the sanity check was a byproduct of how the KVM code was written, i.e. wasn't added to guard against anything in particular.
--- arch/x86/kvm/lapic.c | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-)
arch/x86/kvm/lapic.c +2 -7
@@ -2284,23 +2284,18 @@ void kvm_apic_write_nodecode(struct kvm_vcpu *vcpu, u32 offset)struct kvm_lapic *apic = vcpu->arch.apic;u64 val; -if (apic_x2apic_mode (apic)) { -if (KVM_BUG_ON (kvm_lapic_msr_read (apic, offset, &val), vcpu->kvm)) -return ; - }else { - val =kvm_lapic_get_reg (apic, offset); - } -/* * ICR is a single 64-bit register when x2APIC is enabled. For legacy * xAPIC, ICR writes need to go down the common (slightly slower) path * to get the upper half from ICR2. */ if (apic_x2apic_mode (apic) && offset ==APIC_ICR ) { + val =kvm_lapic_get_reg64 (apic,APIC_ICR );kvm_apic_send_ipi (apic, (u32 )val, (u32)(val >>32 ));trace_kvm_apic_write (APIC_ICR , val); }else {/* TODO: optimize to just emulate side effect w/o one more write */ + val =kvm_lapic_get_reg (apic, offset);kvm_lapic_reg_write (apic, offset, (u32 )val); } }
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 2/33 KVM: x86: Purge "highest ISR" cache when updating APICv state
In reply to Sean ChristophersonPurge the "highest ISR" cache when updating APICv state on a vCPU. The cache must not be used when APICv is active as hardware may emulate EOIs (and other operations) without exiting to KVM.
This fixes a bug where KVM will effectively block IRQs in perpetuity due to the "highest ISR" never getting reset if APICv is activated on a vCPU while an IRQ is in-service. Hardware emulates the EOI and KVM never gets a chance to update its cache.
--- arch/x86/kvm/lapic.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
arch/x86/kvm/lapic.c +1 -2
@@ -2424,6 +2424,7 @@ void kvm_apic_update_apicv(struct kvm_vcpu *vcpu)*/ apic->isr_count =count_vectors (apic->regs +APIC_ISR ); } + apic->highest_isr_cache =-1 ; }void kvm_lapic_reset (struct kvm_vcpu *vcpu,bool init_event)
@@ -2479,7 +2480,6 @@ void kvm_lapic_reset(struct kvm_vcpu *vcpu, bool init_event)kvm_lapic_set_reg (apic,APIC_TMR +0x10 * i,0 ); }kvm_apic_update_apicv (vcpu); - apic->highest_isr_cache =-1 ;update_divide_count (apic);atomic_set (&apic->lapic_timer.pending,0 );
@@ -2767,7 +2767,6 @@ int kvm_apic_set_state(struct kvm_vcpu *vcpu, struct kvm_lapic_state *s)__start_apic_timer (apic,APIC_TMCCT );kvm_lapic_set_reg (apic,APIC_TMCCT ,0 );kvm_apic_update_apicv (vcpu); - apic->highest_isr_cache =-1 ;if (apic->apicv_active) {static_call_cond (kvm_x86_apicv_post_state_restore)(vcpu);static_call_cond (kvm_x86_hwapic_irr_update)(vcpu,apic_find_highest_irr (apic));
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 3/33 KVM: SVM: Flush the "current" TLB when activating AVIC
In reply to Sean ChristophersonFlush the TLB when activating AVIC as the CPU can insert into the TLB while AVIC is "locally" disabled. KVM doesn't treat "APIC hardware disabled" as VM-wide AVIC inhibition, and so when a vCPU has its APIC hardware disabled, AVIC is not guaranteed to be inhibited. As a result, KVM may create a valid NPT mapping for the APIC base, which the CPU can cache as a non-AVIC translation.
Note, Intel handles this in vmx_set_virtual_apic_mode().
--- arch/x86/kvm/svm/avic.c | 6 ++++++ 1 file changed, 6 insertions(+)
arch/x86/kvm/svm/avic.c +6 -0
@@ -86,6 +86,12 @@ static void avic_activate_vmcb(struct vcpu_svm *svm)/* Disabling MSR intercept for x2APIC registers */ svm_set_x2apic_msr_interception (svm, false); }else { +/* +* Flush the TLB, the guest may have inserted a non-APIC +* mapping into the TLB while AVIC was disabled. +*/ +kvm_make_request (KVM_REQ_TLB_FLUSH_CURRENT , &svm->vcpu); +/* For xAVIC and hybrid-xAVIC modes */ vmcb->control.avic_physical_id |=AVIC_MAX_PHYSICAL_ID ;/* Enabling MSR intercept for x2APIC registers */
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Re: [PATCH v5 03/33] KVM: SVM: Flush the "current" TLB when activating AVIC
Quoted 23 lines · Sean Christopherson
Flush the TLB when activating AVIC as the CPU can insert into the TLB while AVIC is "locally" disabled. KVM doesn't treat "APIC hardware disabled" as VM-wide AVIC inhibition, and so when a vCPU has its APIC hardware disabled, AVIC is not guaranteed to be inhibited. As a result, KVM may create a valid NPT mapping for the APIC base, which the CPU can cache as a non-AVIC translation.
Note, Intel handles this in
vmx_set_virtual_apic_mode().Reviewed-by Paolo Bonzini <[email protected]>Signed-off-by Sean Christopherson <[email protected]>--- arch/x86/kvm/svm/avic.c | 6 ++++++ 1 file changed, 6 insertions(+)arch/x86/kvm/svm/avic.c +0
-0@@ -86,6 +86,12 @@ static void avic_activate_vmcb(struct vcpu_svm *svm)/* Disabling MSR intercept for x2APIC registers */ svm_set_x2apic_msr_interception (svm, false);
arch/x86/kvm/svm/avic.c static void avic_activate_vmcb(struct vcpu_svm *svm) · line 97
Quoted 10 lines
arch/x86/kvm/svm/avic.c +6
-0}else { +/* +* Flush the TLB, the guest may have inserted a non-APIC +* mapping into the TLB while AVIC was disabled. +*/ +kvm_make_request (KVM_REQ_TLB_FLUSH_CURRENT , &svm->vcpu); +/* For xAVIC and hybrid-xAVIC modes */ vmcb->control.avic_physical_id |=AVIC_MAX_PHYSICAL_ID ;/* Enabling MSR intercept for x2APIC registers */
Best regards,
Maxim Levitsky
Sean Christopherson
maintainerPATCH v5 4/33 KVM: SVM: Process ICR on AVIC IPI delivery failure due to invalid target
In reply to Sean ChristophersonEmulate ICR writes on AVIC IPI failures due to invalid targets using the same logic as failures due to invalid types. AVIC acceleration fails if _any_ of the targets are invalid, and crucially VM-Exits before sending IPIs to targets that _are_ valid. In logical mode, the destination is a bitmap, i.e. a single IPI can target multiple logical IDs. Doing nothing causes KVM to drop IPIs if at least one target is valid and at least one target is invalid.
--- arch/x86/kvm/svm/avic.c | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-)
arch/x86/kvm/svm/avic.c +9 -7
@@ -502,14 +502,18 @@ int avic_incomplete_ipi_interception(struct kvm_vcpu *vcpu)trace_kvm_avic_incomplete_ipi (vcpu->vcpu_id, icrh, icrl, id, index);switch (id) { +case AVIC_IPI_FAILURE_INVALID_TARGET :case AVIC_IPI_FAILURE_INVALID_INT_TYPE :/* * Emulate IPIs that are not handled by AVIC hardware, which -* only virtualizes Fixed, Edge-Triggered INTRs. The exit is -* a trap, e.g. ICR holds the correct value and RIP has been -* advanced, KVM is responsible only for emulating the IPI. -* Sadly, hardware may sometimes leave the BUSY flag set, in -* which case KVM needs to emulate the ICR write as well in +* only virtualizes Fixed, Edge-Triggered INTRs, and falls over +* if _any_ targets are invalid, e.g. if the logical mode mask +* is a superset of running vCPUs. +* +* The exit is a trap, e.g. ICR holds the correct value and RIP +* has been advanced, KVM is responsible only for emulating the +* IPI. Sadly, hardware may sometimes leave the BUSY flag set, +* in which case KVM needs to emulate the ICR write as well in * order to clear the BUSY flag. */ if (icrl &APIC_ICR_BUSY )
@@ -525,8 +529,6 @@ int avic_incomplete_ipi_interception(struct kvm_vcpu *vcpu)*/ avic_kick_target_vcpus (vcpu->kvm, apic, icrl, icrh, index);break ; -case AVIC_IPI_FAILURE_INVALID_TARGET : -break ;case AVIC_IPI_FAILURE_INVALID_BACKING_PAGE :WARN_ONCE (1 ,"Invalid backing page\n" );break ;
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 5/33 KVM: x86: Don't inhibit APICv/AVIC on xAPIC ID "change" if APIC is disabled
In reply to Sean ChristophersonDon't inhibit APICv/AVIC due to an xAPIC ID mismatch if the APIC is hardware disabled. The ID cannot be consumed while the APIC is disabled, and the ID is guaranteed to be set back to the vcpu_id when the APIC is hardware enabled (architectural behavior correctly emulated by KVM).
--- arch/x86/kvm/lapic.c | 3 +++ 1 file changed, 3 insertions(+)
arch/x86/kvm/lapic.c +3 -0
@@ -2072,6 +2072,9 @@ static void kvm_lapic_xapic_id_updated(struct kvm_lapic *apic) {struct kvm *kvm = apic->vcpu->kvm; +if (!kvm_apic_hw_enabled (apic)) +return ; +if (KVM_BUG_ON (apic_x2apic_mode (apic), kvm))return ;
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 6/33 KVM: x86: Don't inhibit APICv/AVIC if xAPIC ID mismatch is due to 32-bit ID
In reply to Sean ChristophersonTruncate the vcpu_id, a.k.a. x2APIC ID, to an 8-bit value when comparing it against the xAPIC ID to avoid false positives (sort of) on systems with >255 CPUs, i.e. with IDs that don't fit into a u8. The intent of APIC_ID_MODIFIED is to inhibit APICv/AVIC when the xAPIC is changed from it's original value,
The mismatch isn't technically a false positive, as architecturally the xAPIC IDs do end up being aliased in this scenario, and neither APICv nor AVIC correctly handles IPI virtualization when there is aliasing. However, KVM already deliberately does not honor the aliasing behavior that results when an x2APIC ID gets truncated to an xAPIC ID. I.e. the resulting APICv/AVIC behavior is aligned with KVM's existing behavior when KVM's x2APIC hotplug hack is effectively enabled.
If/when KVM provides a way to disable the hotplug hack, APICv/AVIC can piggyback whatever logic disables the optimized APIC map (which is what provides the hotplug hack), i.e. so that KVM's optimized map and APIC virtualization yield the same behavior.
For now, fix the immediate problem of APIC virtualization being disabled for large VMs, which is a much more pressing issue than ensuring KVM honors architectural behavior for APIC ID aliasing.
--- arch/x86/kvm/lapic.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
arch/x86/kvm/lapic.c +6 -1
@@ -2078,7 +2078,12 @@ static void kvm_lapic_xapic_id_updated(struct kvm_lapic *apic)if (KVM_BUG_ON (apic_x2apic_mode (apic), kvm))return ; -if (kvm_xapic_id (apic) == apic->vcpu->vcpu_id) +/* +* Deliberately truncate the vCPU ID when detecting a modified APIC ID +* to avoid false positives if the vCPU ID, i.e. x2APIC ID, is a 32-bit +* value. +*/ +if (kvm_xapic_id (apic) == (u8 )apic->vcpu->vcpu_id)return ;kvm_set_apicv_inhibit (apic->vcpu->kvm,APICV_INHIBIT_REASON_APIC_ID_MODIFIED );
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 7/33 KVM: SVM: Don't put/load AVIC when setting virtual APIC mode
In reply to Sean ChristophersonMove the VMCB updates from avic_refresh_apicv_exec_ctrl() into avic_set_virtual_apic_mode() and invert the dependency being said functions to avoid calling avic_vcpu_{load,put}() and avic_set_pi_irte_mode() when "only" setting the virtual APIC mode.
avic_set_virtual_apic_mode() is invoked from common x86 with preemption enabled, which makes avic_vcpu_{load,put}() unhappy. Luckily, calling those and updating IRTE stuff is unnecessary as the only reason avic_set_virtual_apic_mode() is called is to handle transitions between xAPIC and x2APIC that don't also toggle APICv activation. And if activation doesn't change, there's no need to fiddle with the physical APIC ID table or update IRTE.
The "full" refresh is guaranteed to be called if activation changes in this case as the only call to the "set" path is:
kvm_vcpu_update_apicv(vcpu); static_call_cond(kvm_x86_set_virtual_apic_mode)(vcpu);
and kvm_vcpu_update_apicv() invokes the refresh if activation changes:
if (apic->apicv_active == activate) goto out; apic->apicv_active = activate; kvm_apic_update_apicv(vcpu); static_call(kvm_x86_refresh_apicv_exec_ctrl)(vcpu);
Rename the helper to reflect that it is also called during "refresh".
WARNING: CPU: 183 PID: 49186 at arch/x86/kvm/svm/avic.c:1081 avic_vcpu_put+0xde/0xf0 [kvm_amd] CPU: 183 PID: 49186 Comm: stable Tainted: G O 6.0.0-smp--fcddbca45f0a-sink #34 Hardware name: Google, Inc. Arcadia_IT_80/Arcadia_IT_80, BIOS 10.48.0 01/27/2022 RIP: 0010:avic_vcpu_put+0xde/0xf0 [kvm_amd] avic_refresh_apicv_exec_ctrl+0x142/0x1c0 [kvm_amd] avic_set_virtual_apic_mode+0x5a/0x70 [kvm_amd] kvm_lapic_set_base+0x149/0x1a0 [kvm] kvm_set_apic_base+0x8f/0xd0 [kvm] kvm_set_msr_common+0xa3a/0xdc0 [kvm] svm_set_msr+0x364/0x6b0 [kvm_amd] __kvm_set_msr+0xb8/0x1c0 [kvm] kvm_emulate_wrmsr+0x58/0x1d0 [kvm] msr_interception+0x1c/0x30 [kvm_amd] svm_invoke_exit_handler+0x31/0x100 [kvm_amd] svm_handle_exit+0xfc/0x160 [kvm_amd] vcpu_enter_guest+0x21bb/0x23e0 [kvm] vcpu_run+0x92/0x450 [kvm] kvm_arch_vcpu_ioctl_run+0x43e/0x6e0 [kvm] kvm_vcpu_ioctl+0x559/0x620 [kvm]
--- arch/x86/kvm/svm/avic.c | 31 +++++++++++++++---------------- arch/x86/kvm/svm/svm.c | 2 +- arch/x86/kvm/svm/svm.h | 2 +- 3 files changed, 17 insertions(+), 18 deletions(-)
arch/x86/kvm/svm/avic.c +15 -16
@@ -747,18 +747,6 @@ void avic_apicv_post_state_restore(struct kvm_vcpu *vcpu)avic_handle_ldr_update (vcpu); } -void avic_set_virtual_apic_mode (struct kvm_vcpu *vcpu) -{ -if (!lapic_in_kernel (vcpu) || avic_mode ==AVIC_MODE_NONE ) -return ; - -if (kvm_get_apic_mode (vcpu) ==LAPIC_MODE_INVALID ) { -WARN_ONCE (true,"Invalid local APIC state (vcpu_id=%d)" , vcpu->vcpu_id); -return ; - } -avic_refresh_apicv_exec_ctrl (vcpu); -} -static int avic_set_pi_irte_mode (struct kvm_vcpu *vcpu,bool activate) {int ret =0 ;
@@ -1100,17 +1088,18 @@ void avic_vcpu_put(struct kvm_vcpu *vcpu)WRITE_ONCE (*(svm->avic_physical_id_cache), entry); } - -void avic_refresh_apicv_exec_ctrl (struct kvm_vcpu *vcpu) +void avic_refresh_virtual_apic_mode (struct kvm_vcpu *vcpu) {struct vcpu_svm *svm =to_svm (vcpu);struct vmcb *vmcb = svm->vmcb01.ptr; -bool activated =kvm_vcpu_apicv_active (vcpu); + +if (!lapic_in_kernel (vcpu) || avic_mode ==AVIC_MODE_NONE ) +return ;if (!enable_apicv)return ; -if (activated) { +if (kvm_vcpu_apicv_active (vcpu)) {/** * During AVIC temporary deactivation, guest could update * APIC ID, DFR and LDR registers, which would not be trapped
@@ -1124,6 +1113,16 @@ void avic_refresh_apicv_exec_ctrl(struct kvm_vcpu *vcpu)avic_deactivate_vmcb (svm); }vmcb_mark_dirty (vmcb,VMCB_AVIC ); +} + +void avic_refresh_apicv_exec_ctrl (struct kvm_vcpu *vcpu) +{ +bool activated =kvm_vcpu_apicv_active (vcpu); + +if (!enable_apicv) +return ; + +avic_refresh_virtual_apic_mode (vcpu);if (activated)avic_vcpu_load (vcpu, vcpu->cpu);
arch/x86/kvm/svm/svm.c +1 -1
@@ -4771,7 +4771,7 @@ static struct kvm_x86_ops svm_x86_ops __initdata = { .enable_nmi_window = svm_enable_nmi_window, .enable_irq_window = svm_enable_irq_window, .update_cr8_intercept = svm_update_cr8_intercept, - .set_virtual_apic_mode = avic_set_virtual_apic_mode, + .set_virtual_apic_mode = avic_refresh_virtual_apic_mode, .refresh_apicv_exec_ctrl = avic_refresh_apicv_exec_ctrl, .check_apicv_inhibit_reasons = avic_check_apicv_inhibit_reasons, .apicv_post_state_restore = avic_apicv_post_state_restore,
arch/x86/kvm/svm/svm.h +1 -1
@@ -648,7 +648,7 @@ void avic_vcpu_blocking(struct kvm_vcpu *vcpu);void avic_vcpu_unblocking (struct kvm_vcpu *vcpu);void avic_ring_doorbell (struct kvm_vcpu *vcpu);unsigned long avic_vcpu_get_apicv_inhibit_reasons (struct kvm_vcpu *vcpu); -void avic_set_virtual_apic_mode (struct kvm_vcpu *vcpu); +void avic_refresh_virtual_apic_mode (struct kvm_vcpu *vcpu);/* sev.c */
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 8/33 KVM: x86: Handle APICv updates for APIC "mode" changes via request
In reply to Sean ChristophersonUse KVM_REQ_UPDATE_APICV to react to APIC "mode" changes, i.e. to handle the APIC being hardware enabled/disabled and/or x2APIC being toggled. There is no need to immediately update APICv state, the only requirement is that APICv be updating prior to the next VM-Enter.
Making a request will allow piggybacking KVM_REQ_UPDATE_APICV to "inhibit" the APICv memslot when x2APIC is enabled. Doing that directly from kvm_lapic_set_base() isn't feasible as KVM's SRCU must not be held when modifying memslots (to avoid deadlock), and may or may not be held when kvm_lapic_set_base() is called, i.e. KVM can't do the right thing without tracking that is rightly buried behind CONFIG_PROVE_RCU=y.
--- arch/x86/kvm/lapic.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/x86/kvm/lapic.c +1 -1
@@ -2401,7 +2401,7 @@ void kvm_lapic_set_base(struct kvm_vcpu *vcpu, u64 value)kvm_apic_set_x2apic_id (apic, vcpu->vcpu_id);if ((old_value ^ value) & (MSR_IA32_APICBASE_ENABLE |X2APIC_ENABLE )) { -kvm_vcpu_update_apicv (vcpu); +kvm_make_request (KVM_REQ_APICV_UPDATE , vcpu);static_call_cond (kvm_x86_set_virtual_apic_mode)(vcpu); }
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 9/33 KVM: x86: Move APIC access page helper to common x86 code
In reply to Sean ChristophersonMove the APIC access page allocation helper function to common x86 code, the allocation routine is virtually identical between APICv (VMX) and AVIC (SVM). Keep APICv's gfn_to_page() + put_page() sequence, which verifies that a backing page can be allocated, i.e. that the system isn't under heavy memory pressure. Forcing the backing page to be populated isn't strictly necessary, but skipping the effective prefetch only delays the inevitable.
--- arch/x86/kvm/lapic.c | 35 +++++++++++++++++++++++++++++++++++ arch/x86/kvm/lapic.h | 1 + arch/x86/kvm/svm/avic.c | 41 +++++++---------------------------------- arch/x86/kvm/vmx/vmx.c | 35 +---------------------------------- 4 files changed, 44 insertions(+), 68 deletions(-)
arch/x86/kvm/lapic.c +35 -0
@@ -2435,6 +2435,41 @@ void kvm_apic_update_apicv(struct kvm_vcpu *vcpu) apic->highest_isr_cache =-1 ; } +int kvm_alloc_apic_access_page (struct kvm *kvm) +{ +struct page *page; +void __user *hva; +int ret =0 ; + +mutex_lock (&kvm->slots_lock); +if (kvm->arch.apic_access_memslot_enabled) + goto out; + + hva =__x86_set_memory_region (kvm,APIC_ACCESS_PAGE_PRIVATE_MEMSLOT , +APIC_DEFAULT_PHYS_BASE ,PAGE_SIZE ); +if (IS_ERR (hva)) { + ret =PTR_ERR (hva); + goto out; + } + + page =gfn_to_page (kvm,APIC_DEFAULT_PHYS_BASE >>PAGE_SHIFT ); +if (is_error_page (page)) { + ret = -EFAULT ; + goto out; + } + +/* +* Do not pin the page in memory, so that memory hot-unplug +* is able to migrate it. +*/ +put_page (page); + kvm->arch.apic_access_memslot_enabled = true; +out: +mutex_unlock (&kvm->slots_lock); +return ret; +} +EXPORT_SYMBOL_GPL (kvm_alloc_apic_access_page); +void kvm_lapic_reset (struct kvm_vcpu *vcpu,bool init_event) {struct kvm_lapic *apic = vcpu->arch.apic;
arch/x86/kvm/lapic.h +1 -0
@@ -112,6 +112,7 @@ int kvm_apic_set_irq(struct kvm_vcpu *vcpu, struct kvm_lapic_irq *irq, struct dest_map *dest_map);int kvm_apic_local_deliver (struct kvm_lapic *apic,int lvt_type);void kvm_apic_update_apicv (struct kvm_vcpu *vcpu); +int kvm_alloc_apic_access_page (struct kvm *kvm);bool kvm_irq_delivery_to_apic_fast (struct kvm *kvm,struct kvm_lapic *src,struct kvm_lapic_irq *irq,int *r,struct dest_map *dest_map);
arch/x86/kvm/svm/avic.c +7 -34
53 lines not on this page · raw message
arch/x86/kvm/vmx/vmx.c +1 -34
@@ -3808,39 +3808,6 @@ static void seg_setup(int seg)vmcs_write32 (sf->ar_bytes, ar); } -static int alloc_apic_access_page (struct kvm *kvm) -{ -struct page *page; -void __user *hva; -int ret =0 ; - -mutex_lock (&kvm->slots_lock); -if (kvm->arch.apic_access_memslot_enabled) - goto out; - hva =__x86_set_memory_region (kvm,APIC_ACCESS_PAGE_PRIVATE_MEMSLOT , -APIC_DEFAULT_PHYS_BASE ,PAGE_SIZE ); -if (IS_ERR (hva)) { - ret =PTR_ERR (hva); - goto out; - } - - page =gfn_to_page (kvm,APIC_DEFAULT_PHYS_BASE >>PAGE_SHIFT ); -if (is_error_page (page)) { - ret = -EFAULT ; - goto out; - } - -/* -* Do not pin the page in memory, so that memory hot-unplug -* is able to migrate it. -*/ -put_page (page); - kvm->arch.apic_access_memslot_enabled = true; -out: -mutex_unlock (&kvm->slots_lock); -return ret; -} -int allocate_vpid (void ) {int vpid;
@@ -7394,7 +7361,7 @@ static int vmx_vcpu_create(struct kvm_vcpu *vcpu) vmx->loaded_vmcs = &vmx->vmcs01;if (cpu_need_virtualize_apic_accesses (vcpu)) { - err =alloc_apic_access_page (vcpu->kvm); + err =kvm_alloc_apic_access_page (vcpu->kvm);if (err) goto free_vmcs; }
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 10/33 KVM: x86: Inhibit APIC memslot if x2APIC and AVIC are enabled
In reply to Sean ChristophersonFree the APIC access page memslot if any vCPU enables x2APIC and SVM's AVIC is enabled to prevent accesses to the virtual APIC on vCPUs with x2APIC enabled. On AMD, if its "hybrid" mode is enabled (AVIC is enabled when x2APIC is enabled even without x2AVIC support), keeping the APIC access page memslot results in the guest being able to access the virtual APIC page as x2APIC is fully emulated by KVM. I.e. hardware isn't aware that the guest is operating in x2APIC mode.
Exempt nested SVM's update of APICv state from the new logic as x2APIC can't be toggled on VM-Exit. In practice, invoking the x2APIC logic should be harmless precisely because it should be a glorified nop, but play it safe to avoid latent bugs, e.g. with dropping the vCPU's SRCU lock.
Intel doesn't suffer from the same issue as APICv has fully independent VMCS controls for xAPIC vs. x2APIC virtualization. Technically, KVM should provide bus error semantics and not memory semantics for the APIC page when x2APIC is enabled, but KVM already provides memory semantics in other scenarios, e.g. if APICv/AVIC is enabled and the APIC is hardware disabled (via APIC_BASE MSR).
Note, checking apic_access_memslot_enabled without taking locks relies it being set during vCPU creation (before kvm_vcpu_reset()). vCPUs can race to set the inhibit and delete the memslot, i.e. can get false positives, but can't get false negatives as apic_access_memslot_enabled can't be toggled "on" once any vCPU reaches KVM_RUN.
Opportunistically drop the "can" while updating avic_activate_vmcb()'s comment, i.e. to state that KVM _does_ support the hybrid mode. Move the "Note:" down a line to conform to preferred kernel/KVM multi-line comment style.
Opportunistically update the apicv_update_lock comment, as it isn't actually used to protect apic_access_memslot_enabled (which is protected by slots_lock).
--- arch/x86/include/asm/kvm_host.h | 10 +++++---- arch/x86/kvm/lapic.c | 38 ++++++++++++++++++++++++++++++++- arch/x86/kvm/lapic.h | 1 + arch/x86/kvm/svm/avic.c | 12 +++++------ arch/x86/kvm/svm/nested.c | 2 +- arch/x86/kvm/svm/svm.c | 2 ++ arch/x86/kvm/x86.c | 27 +++++++++++++++++++++-- 7 files changed, 78 insertions(+), 14 deletions(-)
arch/x86/include/asm/kvm_host.h +6 -4
@@ -1249,10 +1249,11 @@ struct kvm_arch {struct kvm_apic_map __rcu *apic_map;atomic_t apic_map_dirty; -/* Protects apic_access_memslot_enabled and apicv_inhibit_reasons */ -struct rw_semaphore apicv_update_lock; -bool apic_access_memslot_enabled; +bool apic_access_memslot_inhibited; + +/* Protects apicv_inhibit_reasons */ +struct rw_semaphore apicv_update_lock;unsigned long apicv_inhibit_reasons;gpa_t wall_clock;
@@ -1599,6 +1600,7 @@ struct kvm_x86_ops {void (*enable_irq_window)(struct kvm_vcpu *vcpu);void (*update_cr8_intercept)(struct kvm_vcpu *vcpu,int tpr,int irr);bool (*check_apicv_inhibit_reasons)(enum kvm_apicv_inhibit reason); +bool allow_apicv_in_x2apic_without_x2apic_virtualization;void (*refresh_apicv_exec_ctrl)(struct kvm_vcpu *vcpu);void (*hwapic_irr_update)(struct kvm_vcpu *vcpu,int max_irr);void (*hwapic_isr_update)(int isr);
@@ -1973,7 +1975,7 @@ gpa_t kvm_mmu_gva_to_gpa_system(struct kvm_vcpu *vcpu, gva_t gva,bool kvm_apicv_activated (struct kvm *kvm);bool kvm_vcpu_apicv_activated (struct kvm_vcpu *vcpu); -void kvm_vcpu_update_apicv (struct kvm_vcpu *vcpu); +void __kvm_vcpu_update_apicv (struct kvm_vcpu *vcpu);void __kvm_set_or_clear_apicv_inhibit (struct kvm *kvm,enum kvm_apicv_inhibit reason,bool set); void kvm_set_or_clear_apicv_inhibit(struct kvm *kvm,
arch/x86/kvm/lapic.c +37 -1
@@ -2442,7 +2442,8 @@ int kvm_alloc_apic_access_page(struct kvm *kvm)int ret =0 ;mutex_lock (&kvm->slots_lock); -if (kvm->arch.apic_access_memslot_enabled) +if (kvm->arch.apic_access_memslot_enabled || + kvm->arch.apic_access_memslot_inhibited) goto out; hva = __x86_set_memory_region(kvm, APIC_ACCESS_PAGE_PRIVATE_MEMSLOT,
@@ -2470,6 +2471,41 @@ int kvm_alloc_apic_access_page(struct kvm *kvm) }EXPORT_SYMBOL_GPL (kvm_alloc_apic_access_page); +void kvm_inhibit_apic_access_page (struct kvm_vcpu *vcpu) +{ +struct kvm *kvm = vcpu->kvm; + +if (!kvm->arch.apic_access_memslot_enabled) +return ; + +kvm_vcpu_srcu_read_unlock (vcpu); + +mutex_lock (&kvm->slots_lock); + +if (kvm->arch.apic_access_memslot_enabled) { +__x86_set_memory_region (kvm,APIC_ACCESS_PAGE_PRIVATE_MEMSLOT ,0 ,0 ); +/* +* Clear "enabled" after the memslot is deleted so that a +* different vCPU doesn't get a false negative when checking +* the flag out of slots_lock. No additional memory barrier is +* needed as modifying memslots requires waiting other vCPUs to +* drop SRCU (see above), and false positives are ok as the +* flag is rechecked after acquiring slots_lock. +*/ + kvm->arch.apic_access_memslot_enabled = false; + +/* +* Mark the memslot as inhibited to prevent reallocating the +* memslot during vCPU creation, e.g. if a vCPU is hotplugged. +*/ + kvm->arch.apic_access_memslot_inhibited = true; + } + +mutex_unlock (&kvm->slots_lock); + +kvm_vcpu_srcu_read_lock (vcpu); +} +void kvm_lapic_reset (struct kvm_vcpu *vcpu,bool init_event) {struct kvm_lapic *apic = vcpu->arch.apic;
arch/x86/kvm/lapic.h +1 -0
@@ -113,6 +113,7 @@ int kvm_apic_set_irq(struct kvm_vcpu *vcpu, struct kvm_lapic_irq *irq,int kvm_apic_local_deliver (struct kvm_lapic *apic,int lvt_type);void kvm_apic_update_apicv (struct kvm_vcpu *vcpu);int kvm_alloc_apic_access_page (struct kvm *kvm); +void kvm_inhibit_apic_access_page (struct kvm_vcpu *vcpu);bool kvm_irq_delivery_to_apic_fast (struct kvm *kvm,struct kvm_lapic *src,struct kvm_lapic_irq *irq,int *r,struct dest_map *dest_map);
arch/x86/kvm/svm/avic.c +6 -6
@@ -72,12 +72,12 @@ static void avic_activate_vmcb(struct vcpu_svm *svm) vmcb->control.int_ctl |=AVIC_ENABLE_MASK ; -/* Note: -* KVM can support hybrid-AVIC mode, where KVM emulates x2APIC -* MSR accesses, while interrupt injection to a running vCPU -* can be achieved using AVIC doorbell. The AVIC hardware still -* accelerate MMIO accesses, but this does not cause any harm -* as the guest is not supposed to access xAPIC mmio when uses x2APIC. +/* +* Note: KVM supports hybrid-AVIC mode, where KVM emulates x2APIC MSR +* accesses, while interrupt injection to a running vCPU can be +* achieved using AVIC doorbell. KVM disables the APIC access page +* (deletes the memslot) if any vCPU has x2APIC enabled, thus enabling +* AVIC in hybrid mode activates only the doorbell mechanism. */ if (apic_x2apic_mode (svm->vcpu.arch.apic) && avic_mode ==AVIC_MODE_X2 ) {
arch/x86/kvm/svm/nested.c +1 -1
@@ -1106,7 +1106,7 @@ int nested_svm_vmexit(struct vcpu_svm *svm)* to benefit from it right away. */ if (kvm_apicv_activated (vcpu->kvm)) -kvm_vcpu_update_apicv (vcpu); +__kvm_vcpu_update_apicv (vcpu);return 0 ; }
arch/x86/kvm/svm/svm.c +2 -0
@@ -5028,6 +5028,8 @@ static __init int svm_hardware_setup(void) svm_x86_ops.vcpu_blocking =NULL ; svm_x86_ops.vcpu_unblocking =NULL ; svm_x86_ops.vcpu_get_apicv_inhibit_reasons =NULL ; + }else if (avic_mode ==AVIC_MODE_X1 ) { + svm_x86_ops.allow_apicv_in_x2apic_without_x2apic_virtualization = true; }if (vls) {
arch/x86/kvm/x86.c +25 -2
@@ -10045,7 +10045,7 @@ void kvm_make_scan_ioapic_request(struct kvm *kvm)kvm_make_all_cpus_request (kvm,KVM_REQ_SCAN_IOAPIC ); } -void kvm_vcpu_update_apicv (struct kvm_vcpu *vcpu) +void __kvm_vcpu_update_apicv (struct kvm_vcpu *vcpu) {struct kvm_lapic *apic = vcpu->arch.apic;bool activate;
@@ -10080,7 +10080,30 @@ void kvm_vcpu_update_apicv(struct kvm_vcpu *vcpu)preempt_enable ();up_read (&vcpu->kvm->arch.apicv_update_lock); } -EXPORT_SYMBOL_GPL (kvm_vcpu_update_apicv); +EXPORT_SYMBOL_GPL (__kvm_vcpu_update_apicv); + +static void kvm_vcpu_update_apicv (struct kvm_vcpu *vcpu) +{ +if (!lapic_in_kernel (vcpu)) +return ; + +/* +* Due to sharing page tables across vCPUs, the xAPIC memslot must be +* deleted if any vCPU has xAPIC virtualization and x2APIC enabled, but +* and hardware doesn't support x2APIC virtualization. E.g. some AMD +* CPUs support AVIC but not x2APIC. KVM still allows enabling AVIC in +* this case so that KVM can the AVIC doorbell to inject interrupts to +* running vCPUs, but KVM must not create SPTEs for the APIC base as +* the vCPU would incorrectly be able to access the vAPIC page via MMIO +* despite being in x2APIC mode. For simplicity, inhibiting the APIC +* access page is sticky. +*/ +if (apic_x2apic_mode (vcpu->arch.apic) && + kvm_x86_ops.allow_apicv_in_x2apic_without_x2apic_virtualization) +kvm_inhibit_apic_access_page (vcpu); + +__kvm_vcpu_update_apicv (vcpu); +}void __kvm_set_or_clear_apicv_inhibit (struct kvm *kvm,enum kvm_apicv_inhibit reason,bool set)
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Re: [PATCH v5 10/33] KVM: x86: Inhibit APIC memslot if x2APIC and AVIC are enabled
Quoted 8 lines · Sean Christopherson
Free the APIC access page memslot if any vCPU enables x2APIC and SVM's AVIC is enabled to prevent accesses to the virtual APIC on vCPUs with x2APIC enabled. On AMD, if its "hybrid" mode is enabled (AVIC is enabled when x2APIC is enabled even without x2AVIC support), keeping the APIC access page memslot results in the guest being able to access the virtual APIC page as x2APIC is fully emulated by KVM. I.e. hardware isn't aware that the guest is operating in x2APIC mode.
Quoted 8 lines
Exempt nested SVM's update of APICv state from the new logic as x2APIC can't be toggled on VM-Exit. In practice, invoking the x2APIC logic should be harmless precisely because it should be a glorified nop, but play it safe to avoid latent bugs, e.g. with dropping the vCPU's SRCU lock.
Intel doesn't suffer from the same issue as APICv has fully independent VMCS controls for xAPIC vs. x2APIC virtualization.
Nit: Intel and AMD with X2AVIC.
Quoted 221 lines
Technically, KVM
should provide bus error semantics and not memory semantics for the APIC page when x2APIC is enabled, but KVM already provides memory semantics in other scenarios, e.g. if APICv/AVIC is enabled and the APIC is hardware disabled (viaAPIC_BASEMSR).Note, checking
apic_access_memslot_enabledwithout taking locks relies it being set during vCPU creation (beforekvm_vcpu_reset()). vCPUs can race to set the inhibit and delete the memslot, i.e. can get false positives, but can't get false negatives asapic_access_memslot_enabledcan't be toggled "on" once any vCPU reachesKVM_RUN.Opportunistically drop the "can" while updating avic_activate_vmcb()'s comment, i.e. to state that KVM _does_ support the hybrid mode. Move the "Note:" down a line to conform to preferred kernel/KVM multi-line comment style.
Opportunistically update the
apicv_update_lockcomment, as it isn't actually used to protectapic_access_memslot_enabled(which is protected byslots_lock).Fixes 0e311d33bfbe ("KVM: SVM: Introduce hybrid-AVIC mode")Signed-off-by Sean Christopherson <[email protected]>--- arch/x86/include/asm/kvm_host.h | 10 +++++---- arch/x86/kvm/lapic.c | 38 ++++++++++++++++++++++++++++++++- arch/x86/kvm/lapic.h | 1 + arch/x86/kvm/svm/avic.c | 12 +++++------ arch/x86/kvm/svm/nested.c | 2 +- arch/x86/kvm/svm/svm.c | 2 ++ arch/x86/kvm/x86.c | 27 +++++++++++++++++++++-- 7 files changed, 78 insertions(+), 14 deletions(-)arch/x86/include/asm/kvm_host.h +6
-4@@ -1249,10 +1249,11 @@ struct kvm_arch {struct kvm_apic_map __rcu *apic_map;atomic_t apic_map_dirty; -/* Protects apic_access_memslot_enabled and apicv_inhibit_reasons */ -struct rw_semaphore apicv_update_lock; -bool apic_access_memslot_enabled; +bool apic_access_memslot_inhibited; + +/* Protects apicv_inhibit_reasons */ +struct rw_semaphore apicv_update_lock;unsigned long apicv_inhibit_reasons;gpa_t wall_clock;@@ -1599,6 +1600,7 @@ struct kvm_x86_ops {void (*enable_irq_window)(struct kvm_vcpu *vcpu);void (*update_cr8_intercept)(struct kvm_vcpu *vcpu,int tpr,int irr);bool (*check_apicv_inhibit_reasons)(enum kvm_apicv_inhibit reason); +bool allow_apicv_in_x2apic_without_x2apic_virtualization;void (*refresh_apicv_exec_ctrl)(struct kvm_vcpu *vcpu);void (*hwapic_irr_update)(struct kvm_vcpu *vcpu,int max_irr);void (*hwapic_isr_update)(int isr);@@ -1973,7 +1975,7 @@ gpa_t kvm_mmu_gva_to_gpa_system(struct kvm_vcpu *vcpu, gva_t gva,bool kvm_apicv_activated (struct kvm *kvm);bool kvm_vcpu_apicv_activated (struct kvm_vcpu *vcpu); -void kvm_vcpu_update_apicv (struct kvm_vcpu *vcpu); +void __kvm_vcpu_update_apicv (struct kvm_vcpu *vcpu);void __kvm_set_or_clear_apicv_inhibit (struct kvm *kvm,enum kvm_apicv_inhibit reason,bool set); void kvm_set_or_clear_apicv_inhibit(struct kvm *kvm,arch/x86/kvm/lapic.c +37
-1@@ -2442,7 +2442,8 @@ int kvm_alloc_apic_access_page(struct kvm *kvm)int ret =0 ;mutex_lock (&kvm->slots_lock); -if (kvm->arch.apic_access_memslot_enabled) +if (kvm->arch.apic_access_memslot_enabled || + kvm->arch.apic_access_memslot_inhibited) goto out; hva = __x86_set_memory_region(kvm, APIC_ACCESS_PAGE_PRIVATE_MEMSLOT,@@ -2470,6 +2471,41 @@ int kvm_alloc_apic_access_page(struct kvm *kvm) }EXPORT_SYMBOL_GPL (kvm_alloc_apic_access_page); +void kvm_inhibit_apic_access_page (struct kvm_vcpu *vcpu) +{ +struct kvm *kvm = vcpu->kvm; + +if (!kvm->arch.apic_access_memslot_enabled) +return ; + +kvm_vcpu_srcu_read_unlock (vcpu); + +mutex_lock (&kvm->slots_lock); + +if (kvm->arch.apic_access_memslot_enabled) { +__x86_set_memory_region (kvm,APIC_ACCESS_PAGE_PRIVATE_MEMSLOT ,0 ,0 ); +/* +* Clear "enabled" after the memslot is deleted so that a +* different vCPU doesn't get a false negative when checking +* the flag out of slots_lock. No additional memory barrier is +* needed as modifying memslots requires waiting other vCPUs to +* drop SRCU (see above), and false positives are ok as the +* flag is rechecked after acquiring slots_lock. +*/ + kvm->arch.apic_access_memslot_enabled = false; + +/* +* Mark the memslot as inhibited to prevent reallocating the +* memslot during vCPU creation, e.g. if a vCPU is hotplugged. +*/ + kvm->arch.apic_access_memslot_inhibited = true; + } + +mutex_unlock (&kvm->slots_lock); + +kvm_vcpu_srcu_read_lock (vcpu); +} +void kvm_lapic_reset (struct kvm_vcpu *vcpu,bool init_event) {struct kvm_lapic *apic = vcpu->arch.apic;arch/x86/kvm/lapic.h +1
-0@@ -113,6 +113,7 @@ int kvm_apic_set_irq(struct kvm_vcpu *vcpu, struct kvm_lapic_irq *irq,int kvm_apic_local_deliver (struct kvm_lapic *apic,int lvt_type);void kvm_apic_update_apicv (struct kvm_vcpu *vcpu);int kvm_alloc_apic_access_page (struct kvm *kvm); +void kvm_inhibit_apic_access_page (struct kvm_vcpu *vcpu);bool kvm_irq_delivery_to_apic_fast (struct kvm *kvm,struct kvm_lapic *src,struct kvm_lapic_irq *irq,int *r,struct dest_map *dest_map);arch/x86/kvm/svm/avic.c +6
-6@@ -72,12 +72,12 @@ static void avic_activate_vmcb(struct vcpu_svm *svm) vmcb->control.int_ctl |=AVIC_ENABLE_MASK ; -/* Note: -* KVM can support hybrid-AVIC mode, where KVM emulates x2APIC -* MSR accesses, while interrupt injection to a running vCPU -* can be achieved using AVIC doorbell. The AVIC hardware still -* accelerate MMIO accesses, but this does not cause any harm -* as the guest is not supposed to access xAPIC mmio when uses x2APIC. +/* +* Note: KVM supports hybrid-AVIC mode, where KVM emulates x2APIC MSR +* accesses, while interrupt injection to a running vCPU can be +* achieved using AVIC doorbell. KVM disables the APIC access page +* (deletes the memslot) if any vCPU has x2APIC enabled, thus enabling +* AVIC in hybrid mode activates only the doorbell mechanism. */ if (apic_x2apic_mode (svm->vcpu.arch.apic) && avic_mode ==AVIC_MODE_X2 ) {arch/x86/kvm/svm/nested.c +1
-1@@ -1106,7 +1106,7 @@ int nested_svm_vmexit(struct vcpu_svm *svm)* to benefit from it right away. */ if (kvm_apicv_activated (vcpu->kvm)) -kvm_vcpu_update_apicv (vcpu); +__kvm_vcpu_update_apicv (vcpu);return 0 ; }arch/x86/kvm/svm/svm.c +2
-0@@ -5028,6 +5028,8 @@ static __init int svm_hardware_setup(void) svm_x86_ops.vcpu_blocking =NULL ; svm_x86_ops.vcpu_unblocking =NULL ; svm_x86_ops.vcpu_get_apicv_inhibit_reasons =NULL ; + }else if (avic_mode ==AVIC_MODE_X1 ) { + svm_x86_ops.allow_apicv_in_x2apic_without_x2apic_virtualization = true; }if (vls) {arch/x86/kvm/x86.c +18
-2@@ -10045,7 +10045,7 @@ void kvm_make_scan_ioapic_request(struct kvm *kvm)kvm_make_all_cpus_request (kvm,KVM_REQ_SCAN_IOAPIC ); } -void kvm_vcpu_update_apicv (struct kvm_vcpu *vcpu) +void __kvm_vcpu_update_apicv (struct kvm_vcpu *vcpu) {struct kvm_lapic *apic = vcpu->arch.apic;bool activate;@@ -10080,7 +10080,30 @@ void kvm_vcpu_update_apicv(struct kvm_vcpu *vcpu)preempt_enable ();up_read (&vcpu->kvm->arch.apicv_update_lock); } -EXPORT_SYMBOL_GPL (kvm_vcpu_update_apicv); +EXPORT_SYMBOL_GPL (__kvm_vcpu_update_apicv); + +static void kvm_vcpu_update_apicv (struct kvm_vcpu *vcpu) +{ +if (!lapic_in_kernel (vcpu)) +return ; + +/* +* Due to sharing page tables across vCPUs, the xAPIC memslot must be +* deleted if any vCPU has xAPIC virtualization and x2APIC enabled, but +* and hardware doesn't support x2APIC virtualization. E.g. some AMD +* CPUs support AVIC but not x2APIC. KVM still allows enabling AVIC in +* this case so that KVM can the AVIC doorbell to inject interrupts to +* running vCPUs, but KVM must not create SPTEs for the APIC base as +* the vCPU would incorrectly be able to access the vAPIC page via MMIO +* despite being in x2APIC mode. For simplicity, inhibiting the APIC +* access page is sticky.
arch/x86/kvm/x86.c void kvm_vcpu_update_apicv(struct kvm_vcpu *vcpu) · line 10109
Quoted 10 lines
arch/x86/kvm/x86.c +7
-0+*/ +if (apic_x2apic_mode (vcpu->arch.apic) && + kvm_x86_ops.allow_apicv_in_x2apic_without_x2apic_virtualization) +kvm_inhibit_apic_access_page (vcpu); + +__kvm_vcpu_update_apicv (vcpu); +}void __kvm_set_or_clear_apicv_inhibit (struct kvm *kvm,enum kvm_apicv_inhibit reason,bool set)
Best regards,
Maxim Levitsky
Sean Christopherson
maintainerPATCH v5 11/33 KVM: SVM: Replace "avic_mode" enum with "x2avic_enabled" boolean
In reply to Sean ChristophersonReplace the "avic_mode" enum with a single bool to track whether or not x2AVIC is enabled. KVM already has "apicv_enabled" that tracks if any flavor of AVIC is enabled, i.e. AVIC_MODE_NONE and AVIC_MODE_X1 are redundant and unnecessary noise.
No functional change intended.
--- arch/x86/kvm/svm/avic.c | 46 +++++++++++++++++++---------------------- arch/x86/kvm/svm/svm.c | 4 ++-- arch/x86/kvm/svm/svm.h | 9 +------- 3 files changed, 24 insertions(+), 35 deletions(-)
arch/x86/kvm/svm/avic.c +21 -25
@@ -53,7 +53,7 @@ static DEFINE_HASHTABLE(svm_vm_data_hash, SVM_VM_DATA_HASH_BITS);static u32 next_vm_id =0 ;static bool next_vm_id_wrapped =0 ;static DEFINE_SPINLOCK (svm_vm_data_hash_lock); -enum avic_modes avic_mode; +bool x2avic_enabled;/* * This is a wrapper of struct amd_iommu_ir_data.
@@ -79,8 +79,7 @@ static void avic_activate_vmcb(struct vcpu_svm *svm)* (deletes the memslot) if any vCPU has x2APIC enabled, thus enabling * AVIC in hybrid mode activates only the doorbell mechanism. */ -if (apic_x2apic_mode (svm->vcpu.arch.apic) && - avic_mode ==AVIC_MODE_X2 ) { +if (x2avic_enabled &&apic_x2apic_mode (svm->vcpu.arch.apic)) { vmcb->control.int_ctl |=X2APIC_MODE_MASK ; vmcb->control.avic_physical_id |=X2AVIC_MAX_PHYSICAL_ID ;/* Disabling MSR intercept for x2APIC registers */
@@ -247,8 +246,8 @@ static u64 *avic_get_physical_id_entry(struct kvm_vcpu *vcpu,u64 *avic_physical_id_table;struct kvm_svm *kvm_svm =to_kvm_svm (vcpu->kvm); -if ((avic_mode ==AVIC_MODE_X1 && index >AVIC_MAX_PHYSICAL_ID ) || - (avic_mode ==AVIC_MODE_X2 && index >X2AVIC_MAX_PHYSICAL_ID )) +if ((!x2avic_enabled && index >AVIC_MAX_PHYSICAL_ID ) || + (index >X2AVIC_MAX_PHYSICAL_ID ))return NULL ; avic_physical_id_table =page_address (kvm_svm->avic_physical_id_table_page);
@@ -262,8 +261,8 @@ static int avic_init_backing_page(struct kvm_vcpu *vcpu)int id = vcpu->vcpu_id;struct vcpu_svm *svm =to_svm (vcpu); -if ((avic_mode ==AVIC_MODE_X1 && id >AVIC_MAX_PHYSICAL_ID ) || - (avic_mode ==AVIC_MODE_X2 && id >X2AVIC_MAX_PHYSICAL_ID )) +if ((!x2avic_enabled && id >AVIC_MAX_PHYSICAL_ID ) || + (id >X2AVIC_MAX_PHYSICAL_ID ))return -EINVAL ;if (!vcpu->arch.apic->regs)
@@ -1066,10 +1065,7 @@ void avic_refresh_virtual_apic_mode(struct kvm_vcpu *vcpu)struct vcpu_svm *svm =to_svm (vcpu);struct vmcb *vmcb = svm->vmcb01.ptr; -if (!lapic_in_kernel (vcpu) || avic_mode ==AVIC_MODE_NONE ) -return ; - -if (!enable_apicv) +if (!lapic_in_kernel (vcpu) || !enable_apicv)return ;if (kvm_vcpu_apicv_active (vcpu)) {
@@ -1145,32 +1141,32 @@ bool avic_hardware_setup(struct kvm_x86_ops *x86_ops)if (!npt_enabled)return false; +/* AVIC is a prerequisite for x2AVIC. */ +if (!boot_cpu_has (X86_FEATURE_AVIC ) && !force_avic) { +if (boot_cpu_has (X86_FEATURE_X2AVIC )) { +pr_warn (FW_BUG "Cannot support x2AVIC due to AVIC is disabled" ); +pr_warn (FW_BUG "Try enable AVIC using force_avic option" ); + } +return false; + } +if (boot_cpu_has (X86_FEATURE_AVIC )) { - avic_mode =AVIC_MODE_X1 ;pr_info ("AVIC enabled\n" ); }else if (force_avic) {/* * Some older systems does not advertise AVIC support. * See Revision Guide for specific AMD processor for more detail. */ - avic_mode =AVIC_MODE_X1 ;pr_warn ("AVIC is not supported in CPUID but force enabled" );pr_warn ("Your system might crash and burn" ); }/* AVIC is a prerequisite for x2AVIC. */ -if (boot_cpu_has (X86_FEATURE_X2AVIC )) { -if (avic_mode ==AVIC_MODE_X1 ) { - avic_mode =AVIC_MODE_X2 ; -pr_info ("x2AVIC enabled\n" ); - }else { -pr_warn (FW_BUG "Cannot support x2AVIC due to AVIC is disabled" ); -pr_warn (FW_BUG "Try enable AVIC using force_avic option" ); - } - } + x2avic_enabled =boot_cpu_has (X86_FEATURE_X2AVIC ); +if (x2avic_enabled) +pr_info ("x2AVIC enabled\n" ); -if (avic_mode !=AVIC_MODE_NONE ) -amd_iommu_register_ga_log_notifier (&avic_ga_log_notifier); +amd_iommu_register_ga_log_notifier (&avic_ga_log_notifier); -return !!avic_mode; +return true; }
arch/x86/kvm/svm/svm.c +2 -2
@@ -813,7 +813,7 @@ void svm_set_x2apic_msr_interception(struct vcpu_svm *svm, bool intercept)if (intercept == svm->x2avic_msrs_intercepted)return ; -if (avic_mode !=AVIC_MODE_X2 || +if (!x2avic_enabled || !apic_x2apic_mode (svm->vcpu.arch.apic))return ;
@@ -5028,7 +5028,7 @@ static __init int svm_hardware_setup(void) svm_x86_ops.vcpu_blocking =NULL ; svm_x86_ops.vcpu_unblocking =NULL ; svm_x86_ops.vcpu_get_apicv_inhibit_reasons =NULL ; - }else if (avic_mode ==AVIC_MODE_X1 ) { + }else if (!x2avic_enabled) { svm_x86_ops.allow_apicv_in_x2apic_without_x2apic_virtualization = true; }
arch/x86/kvm/svm/svm.h +1 -8
@@ -35,14 +35,7 @@ extern u32 msrpm_offsets[MSRPM_OFFSETS] __read_mostly;extern bool npt_enabled;extern int vgif;extern bool intercept_smi; - -enum avic_modes { -AVIC_MODE_NONE =0 , -AVIC_MODE_X1 , -AVIC_MODE_X2 , -}; - -extern enum avic_modes avic_mode; +extern bool x2avic_enabled;/* * Clean bits in VMCB.
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 12/33 KVM: SVM: Compute dest based on sender's x2APIC status for AVIC kick
In reply to Sean ChristophersonCompute the destination from ICRH using the sender's x2APIC status, not each (potential) target's x2APIC status.
--- arch/x86/kvm/svm/avic.c | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-)
arch/x86/kvm/svm/avic.c +1 -7
@@ -429,6 +429,7 @@ static int avic_kick_target_vcpus_fast(struct kvm *kvm, struct kvm_lapic *sourcestatic void avic_kick_target_vcpus (struct kvm *kvm,struct kvm_lapic *source,u32 icrl,u32 icrh,u32 index) { +u32 dest =apic_x2apic_mode (source) ? icrh :GET_XAPIC_DEST_FIELD (icrh);unsigned long i;struct kvm_vcpu *vcpu;
@@ -444,13 +445,6 @@ static void avic_kick_target_vcpus(struct kvm *kvm, struct kvm_lapic *source,* since entered the guest will have processed pending IRQs at VMRUN. */ kvm_for_each_vcpu (i, vcpu, kvm) { -u32 dest; - -if (apic_x2apic_mode (vcpu->arch.apic)) - dest = icrh; -else - dest =GET_XAPIC_DEST_FIELD (icrh); -if (kvm_apic_match_dest (vcpu, source, icrl &APIC_SHORT_MASK , dest, icrl &APIC_DEST_MASK )) { vcpu->arch.apic->irr_pending = true;
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 13/33 KVM: SVM: Fix x2APIC Logical ID calculation for avic_kick_target_vcpus_fast
In reply to Sean ChristophersonFrom: Suravee Suthikulpanit <[email protected]>
For X2APIC ID in cluster mode, the logical ID is bit [15:0].
--- arch/x86/kvm/svm/avic.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/x86/kvm/svm/avic.c +1 -1
@@ -356,7 +356,7 @@ static int avic_kick_target_vcpus_fast(struct kvm *kvm, struct kvm_lapic *sourceif (apic_x2apic_mode (source)) {/* 16 bit dest mask, 16 bit cluster id */ - bitmap = dest &0xFFFF0000 ; + bitmap = dest &0xFFFF ; cluster = (dest >>16 ) <<4 ; }else if (kvm_lapic_get_reg (source,APIC_DFR ) ==APIC_DFR_FLAT ) {/* 8 bit dest mask*/
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 14/33 Revert "KVM: SVM: Use target APIC ID to complete x2AVIC IRQs when possible"
In reply to Sean ChristophersonDue to a likely mismerge of patches, KVM ended up with a superfluous commit to "enable" AVIC's fast path for x2AVIC mode. Even worse, the superfluous commit has several bugs and creates a nasty local shadow variable.
Rather than fix the bugs piece-by-piece[*] to achieve the same end result, revert the patch wholesale.
Opportunistically add a comment documenting the x2AVIC dependencies.
This reverts commit 8c9e639da435874fb845c4d296ce55664071ea7a.
[*] https://lore.kernel.org/all/[email protected]
--- arch/x86/kvm/svm/avic.c | 29 +++++++++++------------------ 1 file changed, 11 insertions(+), 18 deletions(-)
arch/x86/kvm/svm/avic.c +11 -18
@@ -378,7 +378,17 @@ static int avic_kick_target_vcpus_fast(struct kvm *kvm, struct kvm_lapic *source logid_index = cluster +__ffs (bitmap); -if (!apic_x2apic_mode (source)) { +if (apic_x2apic_mode (source)) { +/* +* For x2APIC, the logical APIC ID is a read-only value +* that is derived from the x2APIC ID, thus the x2APIC +* ID can be found by reversing the calculation (done +* above). Note, bits 31:20 of the x2APIC ID are not +* propagated to the logical ID, but KVM limits the +* x2APIC ID limited to KVM_MAX_VCPU_IDS. +*/ + l1_physical_id = logid_index; + }else {u32 *avic_logical_id_table =page_address (kvm_svm->avic_logical_id_table_page);
@@ -393,23 +403,6 @@ static int avic_kick_target_vcpus_fast(struct kvm *kvm, struct kvm_lapic *source l1_physical_id = logid_entry &AVIC_LOGICAL_ID_ENTRY_GUEST_PHYSICAL_ID_MASK ; - }else { -/* -* For x2APIC logical mode, cannot leverage the index. -* Instead, calculate physical ID from logical ID in ICRH. -*/ -int cluster = (icrh &0xffff0000 ) >>16 ; -int apic =ffs (icrh &0xffff ) -1 ; - -/* -* If the x2APIC logical ID sub-field (i.e. icrh[15:0]) -* contains anything but a single bit, we cannot use the -* fast path, because it is limited to a single vCPU. -*/ -if (apic <0 || icrh != (1 << apic)) -return -EINVAL ; - - l1_physical_id = (cluster <<4 ) + apic; } }
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 15/33 KVM: SVM: Document that vCPU ID == APIC ID in AVIC kick fastpatch
In reply to Sean ChristophersonDocument that AVIC is inhibited if any vCPU's APIC ID diverges from its vCPU ID, i.e. that there's no need to check for a destination match in the AVIC kick fast path.
Opportunistically tweak comments to remove "guest bug", as that suggests KVM is punting on error handling, which is not the case. Targeting a non-existent vCPU or no vCPUs _may_ be a guest software bug, but whether or not it's a guest bug is irrelevant. Such behavior is architecturally legal and thus needs to faithfully emulated by KVM (and it is).
--- arch/x86/kvm/svm/avic.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-)
arch/x86/kvm/svm/avic.c +7 -3
@@ -368,8 +368,8 @@ static int avic_kick_target_vcpus_fast(struct kvm *kvm, struct kvm_lapic *source cluster = (dest >>4 ) <<2 ; } +/* Nothing to do if there are no destinations in the cluster. */ if (unlikely (!bitmap)) -/* guest bug: nobody to send the logical interrupt to */ return 0 ;if (!is_power_of_2 (bitmap))
@@ -397,7 +397,7 @@ static int avic_kick_target_vcpus_fast(struct kvm *kvm, struct kvm_lapic *sourceif (WARN_ON_ONCE (index != logid_index))return -EINVAL ; -/* guest bug: non existing/reserved logical destination */ +/* Nothing to do if the logical destination is invalid. */ if (unlikely (!(logid_entry &AVIC_LOGICAL_ID_ENTRY_VALID_MASK )))return 0 ;
@@ -406,9 +406,13 @@ static int avic_kick_target_vcpus_fast(struct kvm *kvm, struct kvm_lapic *source } } +/* +* KVM inhibits AVIC if any vCPU ID diverges from the vCPUs APIC ID, +* i.e. APIC ID == vCPU ID. Once again, nothing to do if the target +* vCPU doesn't exist. +*/ target_vcpu =kvm_get_vcpu_by_id (kvm, l1_physical_id);if (unlikely (!target_vcpu)) -/* guest bug: non existing vCPU is a target of this IPI*/ return 0 ; target_vcpu->arch.apic->irr_pending = true;
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 16/33 KVM: SVM: Add helper to perform final AVIC "kick" of single vCPU
In reply to Sean ChristophersonAdd a helper to perform the final kick, two instances of the ICR decoding is one too many.
No functional change intended.
--- arch/x86/kvm/svm/avic.c | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-)
arch/x86/kvm/svm/avic.c +13 -12
@@ -317,6 +317,16 @@ void avic_ring_doorbell(struct kvm_vcpu *vcpu)put_cpu (); } + +static void avic_kick_vcpu (struct kvm_vcpu *vcpu,u32 icrl) +{ + vcpu->arch.apic->irr_pending = true; +svm_complete_interrupt_delivery (vcpu, + icrl &APIC_MODE_MASK , + icrl &APIC_INT_LEVELTRIG , + icrl &APIC_VECTOR_MASK ); +} +/* * A fast-path version of avic_kick_target_vcpus(), which attempts to match * destination APIC ID to vCPU without looping through all vCPUs.
@@ -415,11 +425,7 @@ static int avic_kick_target_vcpus_fast(struct kvm *kvm, struct kvm_lapic *sourceif (unlikely (!target_vcpu))return 0 ; - target_vcpu->arch.apic->irr_pending = true; -svm_complete_interrupt_delivery (target_vcpu, - icrl &APIC_MODE_MASK , - icrl &APIC_INT_LEVELTRIG , - icrl &APIC_VECTOR_MASK ); +avic_kick_vcpu (target_vcpu, icrl);return 0 ; }
@@ -443,13 +449,8 @@ static void avic_kick_target_vcpus(struct kvm *kvm, struct kvm_lapic *source,*/ kvm_for_each_vcpu (i, vcpu, kvm) {if (kvm_apic_match_dest (vcpu, source, icrl &APIC_SHORT_MASK , - dest, icrl &APIC_DEST_MASK )) { - vcpu->arch.apic->irr_pending = true; -svm_complete_interrupt_delivery (vcpu, - icrl &APIC_MODE_MASK , - icrl &APIC_INT_LEVELTRIG , - icrl &APIC_VECTOR_MASK ); - } + dest, icrl &APIC_DEST_MASK )) +avic_kick_vcpu (vcpu, icrl); } }
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 17/33 KVM: x86: Explicitly skip optimized logical map setup if vCPU's LDR==0
In reply to Sean ChristophersonExplicitly skip the optimized map setup if the vCPU's LDR is '0', i.e. if the vCPU will never respond to logical mode interrupts. KVM already skips setup in this case, but relies on kvm_apic_map_get_logical_dest() to generate mask==0. KVM still needs the mask=0 check as a non-zero LDR can yield mask==0 depending on the mode, but explicitly handling the LDR will make it simpler to clean up the logical mode tracking in the future.
No functional change intended.
--- arch/x86/kvm/lapic.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
arch/x86/kvm/lapic.c +3 -1
@@ -286,10 +286,12 @@ void kvm_recalculate_apic_map(struct kvm *kvm)continue ; ldr =kvm_lapic_get_reg (apic,APIC_LDR ); +if (!ldr) +continue ;if (apic_x2apic_mode (apic)) { new->mode |=KVM_APIC_MODE_X2APIC ; - }else if (ldr) { + }else { ldr =GET_APIC_LOGICAL_ID (ldr);if (kvm_lapic_get_reg (apic,APIC_DFR ) ==APIC_DFR_FLAT ) new->mode |=KVM_APIC_MODE_XAPIC_FLAT ;
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 18/33 KVM: x86: Explicitly track all possibilities for APIC map's logical modes
In reply to Sean ChristophersonTrack all possibilities for the optimized APIC map's logical modes instead of overloading the pseudo-bitmap and treating any "unknown" value as "invalid".
As documented by the now-stale comment above the mode values, the values did have meaning when the optimized map was originally added. That dependent logical was removed by commit e45115b62f9a ("KVM: x86: use physical LAPIC array for logical x2APIC"), but the obfuscated behavior and its comment were left behind.
Opportunistically rename "mode" to "logical_mode", partly to make it clear that the "disabled" case applies only to the logical map, but also to prove that there is no lurking code that expects "mode" to be a bitmap.
Functionally, this is a glorified nop.
--- arch/x86/include/asm/kvm_host.h | 29 ++++++++++++++++-------- arch/x86/kvm/lapic.c | 40 ++++++++++++++++++++++++++------- 2 files changed, 52 insertions(+), 17 deletions(-)
arch/x86/include/asm/kvm_host.h +20 -9
@@ -1022,19 +1022,30 @@ struct kvm_arch_memory_slot { };/* -* We use as the mode the number of bits allocated in the LDR for the -* logical processor ID. It happens that these are all powers of two. -* This makes it is very easy to detect cases where the APICs are -* configured for multiple modes; in that case, we cannot use the map and -* hence cannot use kvm_irq_delivery_to_apic_fast either. +* Track the mode of the optimized logical map, as the rules for decoding the +* destination vary per mode. Enabling the optimized logical map requires all +* software-enabled local APIs to be in the same mode, each addressable APIC to +* be mapped to only one MDA, and each MDA to map to at most one APIC. */ -#define KVM_APIC_MODE_XAPIC_CLUSTER 4 -#define KVM_APIC_MODE_XAPIC_FLAT 8 -#define KVM_APIC_MODE_X2APIC 16 +enum kvm_apic_logical_mode { +/* All local APICs are software disabled. */ +KVM_APIC_MODE_SW_DISABLED , +/* All software enabled local APICs in xAPIC cluster addressing mode. */ +KVM_APIC_MODE_XAPIC_CLUSTER , +/* All software enabled local APICs in xAPIC flat addressing mode. */ +KVM_APIC_MODE_XAPIC_FLAT , +/* All software enabled local APICs in x2APIC mode. */ +KVM_APIC_MODE_X2APIC , +/* +* Optimized map disabled, e.g. not all local APICs in the same logical +* mode, same logical ID assigned to multiple APICs, etc. +*/ +KVM_APIC_MODE_MAP_DISABLED , +};struct kvm_apic_map {struct rcu_head rcu; -u8 mode; +enum kvm_apic_logical_mode logical_mode;u32 max_apic_id;union {struct kvm_lapic *xapic_flat_map[8 ];
arch/x86/kvm/lapic.c +32 -8
@@ -168,7 +168,12 @@ static bool kvm_use_posted_timer_interrupt(struct kvm_vcpu *vcpu)static inline bool kvm_apic_map_get_logical_dest (struct kvm_apic_map *map,u32 dest_id,struct kvm_lapic ***cluster,u16 *mask) { -switch (map->mode) { +switch (map->logical_mode) { +case KVM_APIC_MODE_SW_DISABLED : +/* Arbitrarily use the flat map so that @cluster isn't NULL. */ + *cluster = map->xapic_flat_map; + *mask =0 ; +return true;case KVM_APIC_MODE_X2APIC : {u32 offset = (dest_id >>16 ) *16 ;u32 max_apic_id = map->max_apic_id;
@@ -193,8 +198,10 @@ static inline bool kvm_apic_map_get_logical_dest(struct kvm_apic_map *map, *cluster = map->xapic_cluster_map[(dest_id >>4 ) &0xf ]; *mask = dest_id &0xf ;return true; +case KVM_APIC_MODE_MAP_DISABLED : +return false;default : -/* Not optimized. */ +WARN_ON_ONCE (1 );return false; } }
@@ -256,10 +263,12 @@ void kvm_recalculate_apic_map(struct kvm *kvm) goto out; new->max_apic_id = max_id; + new->logical_mode =KVM_APIC_MODE_SW_DISABLED ;kvm_for_each_vcpu (i, vcpu, kvm) {struct kvm_lapic *apic = vcpu->arch.apic;struct kvm_lapic **cluster; +enum kvm_apic_logical_mode logical_mode;u16 mask;u32 ldr;u8 xapic_id;
@@ -282,7 +291,8 @@ void kvm_recalculate_apic_map(struct kvm *kvm)if (!apic_x2apic_mode (apic) && !new->phys_map[xapic_id]) new->phys_map[xapic_id] = apic; -if (!kvm_apic_sw_enabled (apic)) +if (new->logical_mode ==KVM_APIC_MODE_MAP_DISABLED || + !kvm_apic_sw_enabled (apic))continue ; ldr =kvm_lapic_get_reg (apic,APIC_LDR );
@@ -290,17 +300,31 @@ void kvm_recalculate_apic_map(struct kvm *kvm)continue ;if (apic_x2apic_mode (apic)) { - new->mode |=KVM_APIC_MODE_X2APIC ; + logical_mode =KVM_APIC_MODE_X2APIC ; }else { ldr =GET_APIC_LOGICAL_ID (ldr);if (kvm_lapic_get_reg (apic,APIC_DFR ) ==APIC_DFR_FLAT ) - new->mode |=KVM_APIC_MODE_XAPIC_FLAT ; + logical_mode =KVM_APIC_MODE_XAPIC_FLAT ;else - new->mode |=KVM_APIC_MODE_XAPIC_CLUSTER ; + logical_mode =KVM_APIC_MODE_XAPIC_CLUSTER ; } -if (!kvm_apic_map_get_logical_dest (new, ldr, &cluster, &mask)) +/* +* To optimize logical mode delivery, all software-enabled APICs must +* be configured for the same mode. +*/ +if (new->logical_mode ==KVM_APIC_MODE_SW_DISABLED ) { + new->logical_mode = logical_mode; + }else if (new->logical_mode != logical_mode) { + new->logical_mode =KVM_APIC_MODE_MAP_DISABLED ;continue ; + } + +if (WARN_ON_ONCE (!kvm_apic_map_get_logical_dest (new, ldr, + &cluster, &mask))) { + new->logical_mode =KVM_APIC_MODE_MAP_DISABLED ; +continue ; + }if (mask) cluster[ffs (mask) -1 ] = apic;
@@ -953,7 +977,7 @@ static bool kvm_apic_is_broadcast_dest(struct kvm *kvm, struct kvm_lapic **src, {if (kvm->arch.x2apic_broadcast_quirk_disabled) {if ((irq->dest_id ==APIC_BROADCAST && - map->mode !=KVM_APIC_MODE_X2APIC )) + map->logical_mode !=KVM_APIC_MODE_X2APIC ))return true;if (irq->dest_id ==X2APIC_BROADCAST )return true;
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Re: [PATCH v5 18/33] KVM: x86: Explicitly track all possibilities for APIC map's logical modes
Quoted 156 lines · Sean Christopherson
Track all possibilities for the optimized APIC map's logical modes instead of overloading the pseudo-bitmap and treating any "unknown" value as "invalid".
As documented by the now-stale comment above the mode values, the values did have meaning when the optimized map was originally added. That dependent logical was removed by commit
e45115b62f9a("KVM: x86: use physical LAPIC array for logical x2APIC"), but the obfuscated behavior and its comment were left behind.Opportunistically rename "mode" to "
logical_mode", partly to make it clear that the "disabled" case applies only to the logical map, but also to prove that there is no lurking code that expects "mode" to be a bitmap.Functionally, this is a glorified nop.
Signed-off-by Sean Christopherson <[email protected]>--- arch/x86/include/asm/kvm_host.h | 29 ++++++++++++++++-------- arch/x86/kvm/lapic.c | 40 ++++++++++++++++++++++++++------- 2 files changed, 52 insertions(+), 17 deletions(-)arch/x86/include/asm/kvm_host.h +20
-9@@ -1022,19 +1022,30 @@ struct kvm_arch_memory_slot { };/* -* We use as the mode the number of bits allocated in the LDR for the -* logical processor ID. It happens that these are all powers of two. -* This makes it is very easy to detect cases where the APICs are -* configured for multiple modes; in that case, we cannot use the map and -* hence cannot use kvm_irq_delivery_to_apic_fast either. +* Track the mode of the optimized logical map, as the rules for decoding the +* destination vary per mode. Enabling the optimized logical map requires all +* software-enabled local APIs to be in the same mode, each addressable APIC to +* be mapped to only one MDA, and each MDA to map to at most one APIC. */ -#define KVM_APIC_MODE_XAPIC_CLUSTER 4 -#define KVM_APIC_MODE_XAPIC_FLAT 8 -#define KVM_APIC_MODE_X2APIC 16 +enum kvm_apic_logical_mode { +/* All local APICs are software disabled. */ +KVM_APIC_MODE_SW_DISABLED , +/* All software enabled local APICs in xAPIC cluster addressing mode. */ +KVM_APIC_MODE_XAPIC_CLUSTER , +/* All software enabled local APICs in xAPIC flat addressing mode. */ +KVM_APIC_MODE_XAPIC_FLAT , +/* All software enabled local APICs in x2APIC mode. */ +KVM_APIC_MODE_X2APIC , +/* +* Optimized map disabled, e.g. not all local APICs in the same logical +* mode, same logical ID assigned to multiple APICs, etc. +*/ +KVM_APIC_MODE_MAP_DISABLED , +};struct kvm_apic_map {struct rcu_head rcu; -u8 mode; +enum kvm_apic_logical_mode logical_mode;u32 max_apic_id;union {struct kvm_lapic *xapic_flat_map[8 ];arch/x86/kvm/lapic.c +31
-7@@ -168,7 +168,12 @@ static bool kvm_use_posted_timer_interrupt(struct kvm_vcpu *vcpu)static inline bool kvm_apic_map_get_logical_dest (struct kvm_apic_map *map,u32 dest_id,struct kvm_lapic ***cluster,u16 *mask) { -switch (map->mode) { +switch (map->logical_mode) { +case KVM_APIC_MODE_SW_DISABLED : +/* Arbitrarily use the flat map so that @cluster isn't NULL. */ + *cluster = map->xapic_flat_map; + *mask =0 ; +return true;case KVM_APIC_MODE_X2APIC : {u32 offset = (dest_id >>16 ) *16 ;u32 max_apic_id = map->max_apic_id;@@ -193,8 +198,10 @@ static inline bool kvm_apic_map_get_logical_dest(struct kvm_apic_map *map, *cluster = map->xapic_cluster_map[(dest_id >>4 ) &0xf ]; *mask = dest_id &0xf ;return true; +case KVM_APIC_MODE_MAP_DISABLED : +return false;default : -/* Not optimized. */ +WARN_ON_ONCE (1 );return false; } }@@ -256,10 +263,12 @@ void kvm_recalculate_apic_map(struct kvm *kvm) goto out; new->max_apic_id = max_id; + new->logical_mode =KVM_APIC_MODE_SW_DISABLED ;kvm_for_each_vcpu (i, vcpu, kvm) {struct kvm_lapic *apic = vcpu->arch.apic;struct kvm_lapic **cluster; +enum kvm_apic_logical_mode logical_mode;u16 mask;u32 ldr;u8 xapic_id;@@ -282,7 +291,8 @@ void kvm_recalculate_apic_map(struct kvm *kvm)if (!apic_x2apic_mode (apic) && !new->phys_map[xapic_id]) new->phys_map[xapic_id] = apic; -if (!kvm_apic_sw_enabled (apic)) +if (new->logical_mode ==KVM_APIC_MODE_MAP_DISABLED || + !kvm_apic_sw_enabled (apic))continue ; ldr =kvm_lapic_get_reg (apic,APIC_LDR );@@ -290,17 +300,31 @@ void kvm_recalculate_apic_map(struct kvm *kvm)continue ;if (apic_x2apic_mode (apic)) { - new->mode |=KVM_APIC_MODE_X2APIC ; + logical_mode =KVM_APIC_MODE_X2APIC ; }else { ldr =GET_APIC_LOGICAL_ID (ldr);if (kvm_lapic_get_reg (apic,APIC_DFR ) ==APIC_DFR_FLAT ) - new->mode |=KVM_APIC_MODE_XAPIC_FLAT ; + logical_mode =KVM_APIC_MODE_XAPIC_FLAT ;else - new->mode |=KVM_APIC_MODE_XAPIC_CLUSTER ; + logical_mode =KVM_APIC_MODE_XAPIC_CLUSTER ; } -if (!kvm_apic_map_get_logical_dest (new, ldr, &cluster, &mask)) +/* +* To optimize logical mode delivery, all software-enabled APICs must +* be configured for the same mode. +*/ +if (new->logical_mode ==KVM_APIC_MODE_SW_DISABLED ) { + new->logical_mode = logical_mode; + }else if (new->logical_mode != logical_mode) { + new->logical_mode =KVM_APIC_MODE_MAP_DISABLED ;continue ; + } + +if (WARN_ON_ONCE (!kvm_apic_map_get_logical_dest (new, ldr, + &cluster, &mask))) { + new->logical_mode =KVM_APIC_MODE_MAP_DISABLED ; +continue ; + }if (mask) cluster[ffs (mask) -1 ] = apic;
arch/x86/kvm/lapic.c static bool kvm_apic_is_broadcast_dest(struct kvm *kvm, struct kvm_lapic **src, · line 983
Quoted 8 lines
arch/x86/kvm/lapic.c +1
-1@@ -953,7 +977,7 @@ static bool kvm_apic_is_broadcast_dest(struct kvm *kvm, struct kvm_lapic **src, {if (kvm->arch.x2apic_broadcast_quirk_disabled) {if ((irq->dest_id ==APIC_BROADCAST && - map->mode !=KVM_APIC_MODE_X2APIC )) + map->logical_mode !=KVM_APIC_MODE_X2APIC ))return true;if (irq->dest_id ==X2APIC_BROADCAST )return true;
Best regards,
Maxim Levitsky
Sean Christopherson
maintainerPATCH v5 19/33 KVM: x86: Skip redundant x2APIC logical mode optimized cluster setup
In reply to Sean ChristophersonSkip the optimized cluster[] setup for x2APIC logical mode, as KVM reuses the optimized map's phys_map[] and doesn't actually need to insert the target apic into the cluster[]. The LDR is derived from the x2APIC ID, and both are read-only in KVM, thus the vCPU's cluster[ldr] is guaranteed to be the same entry as the vCPU's phys_map[x2apic_id] entry.
Skipping the unnecessary setup will allow a future fix for aliased xAPIC logical IDs to simply require that cluster[ldr] is non-NULL, i.e. won't have to special case x2APIC.
Alternatively, the future check could allow "cluster[ldr] == apic", but that ends up being terribly confusing because cluster[ldr] is only set at the very end, i.e. it's only possible due to x2APIC's shenanigans.
Another alternative would be to send x2APIC down a separate path _after_ the calculation and then assert that all of the above, but the resulting code is rather messy, and it's arguably unnecessary since asserting that the actual LDR matches the expected LDR means that simply testing that interrupts are delivered correctly provides the same guarantees.
--- arch/x86/kvm/lapic.c | 22 +++++++++++++++++----- 1 file changed, 17 insertions(+), 5 deletions(-)
arch/x86/kvm/lapic.c +17 -5
@@ -166,6 +166,11 @@ static bool kvm_use_posted_timer_interrupt(struct kvm_vcpu *vcpu)return kvm_can_post_timer_interrupt (vcpu) && vcpu->mode ==IN_GUEST_MODE ; } +static inline u32 kvm_apic_calc_x2apic_ldr (u32 id) +{ +return ((id >>4 ) <<16 ) | (1 << (id &0xf )); +} +static inline bool kvm_apic_map_get_logical_dest (struct kvm_apic_map *map,u32 dest_id,struct kvm_lapic ***cluster,u16 *mask) {switch (map->logical_mode) {
@@ -320,6 +325,18 @@ void kvm_recalculate_apic_map(struct kvm *kvm)continue ; } +/* +* In x2APIC mode, the LDR is read-only and derived directly +* from the x2APIC ID, thus is guaranteed to be addressable. +* KVM reuses kvm_apic_map.phys_map to optimize logical mode +* x2APIC interrupts by reversing the LDR calculation to get +* cluster of APICs, i.e. no additional work is required. +*/ +if (apic_x2apic_mode (apic)) { +WARN_ON_ONCE (ldr !=kvm_apic_calc_x2apic_ldr (x2apic_id)); +continue ; + } +if (WARN_ON_ONCE (!kvm_apic_map_get_logical_dest (new, ldr, &cluster, &mask))) { new->logical_mode =KVM_APIC_MODE_MAP_DISABLED ;
@@ -386,11 +403,6 @@ static inline void kvm_apic_set_dfr(struct kvm_lapic *apic, u32 val)atomic_set_release (&apic->vcpu->kvm->arch.apic_map_dirty,DIRTY ); } -static inline u32 kvm_apic_calc_x2apic_ldr (u32 id) -{ -return ((id >>4 ) <<16 ) | (1 << (id &0xf )); -} -static inline void kvm_apic_set_x2apic_id (struct kvm_lapic *apic,u32 id) {u32 ldr =kvm_apic_calc_x2apic_ldr (id);
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 20/33 KVM: x86: Disable APIC logical map if logical ID covers multiple MDAs
In reply to Sean ChristophersonDisable the optimized APIC logical map if a logical ID covers multiple MDAs, i.e. if a vCPU has multiple bits set in its ID. In logical mode, events match if "ID & MDA != 0", i.e. creating an entry for only the first bit can cause interrupts to be missed.
Note, creating an entry for every bit is also wrong as KVM would generate IPIs for every matching bit. It would be possible to teach KVM to play nice with this edge case, but it is very much an edge case and probably not used in any real world OS, i.e. it's not worth optimizing.
--- arch/x86/kvm/lapic.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)
arch/x86/kvm/lapic.c +8 -2
@@ -343,8 +343,14 @@ void kvm_recalculate_apic_map(struct kvm *kvm)continue ; } -if (mask) - cluster[ffs (mask) -1 ] = apic; +if (!mask) +continue ; + +if (!is_power_of_2 (mask)) { + new->logical_mode =KVM_APIC_MODE_MAP_DISABLED ; +continue ; + } + cluster[ffs (mask) -1 ] = apic; } out: old = rcu_dereference_protected(kvm->arch.apic_map,
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 21/33 KVM: x86: Disable APIC logical map if vCPUs are aliased in logical mode
In reply to Sean ChristophersonDisable the optimized APIC logical map if multiple vCPUs are aliased to the same logical ID. Architecturally, all CPUs whose logical ID matches the MDA are supposed to receive the interrupt; overwriting existing map entries can result in missed IPIs.
--- arch/x86/kvm/lapic.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
arch/x86/kvm/lapic.c +3 -2
@@ -346,11 +346,12 @@ void kvm_recalculate_apic_map(struct kvm *kvm)if (!mask)continue ; -if (!is_power_of_2 (mask)) { + ldr =ffs (mask) -1 ; +if (!is_power_of_2 (mask) || cluster[ldr]) { new->logical_mode =KVM_APIC_MODE_MAP_DISABLED ;continue ; } - cluster[ffs (mask) -1 ] = apic; + cluster[ldr] = apic; } out: old = rcu_dereference_protected(kvm->arch.apic_map,
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 22/33 KVM: x86: Honor architectural behavior for aliased 8-bit APIC IDs
In reply to Sean ChristophersonApply KVM's hotplug hack if and only if userspace has enabled 32-bit IDs for x2APIC. If 32-bit IDs are not enabled, disable the optimized map to honor x86 architectural behavior if multiple vCPUs shared a physical APIC ID. As called out in the changelog that added the hack, all CPUs whose (possibly truncated) APIC ID matches the target are supposed to receive the IPI.
KVM intentionally differs from real hardware, because real hardware (Knights Landing) does just "x2apic_id & 0xff" to decide whether to accept the interrupt in xAPIC mode and it can deliver one interrupt to more than one physical destination, e.g. 0x123 to 0x123 and 0x23.
Applying the hack even when x2APIC is not fully enabled means KVM doesn't correctly handle scenarios where the guest has aliased xAPIC IDs across multiple vCPUs, as only the vCPU with the lowest vCPU ID will receive any interrupts. It's extremely unlikely any real world guest aliases APIC IDs, or even modifies APIC IDs, but KVM's behavior is arbitrary, e.g. the lowest vCPU ID "wins" regardless of which vCPU is "aliasing" and which vCPU is "normal".
Furthermore, the hack is _not_ guaranteed to work! The hack works if and only if the optimized APIC map is successfully allocated. If the map allocation fails (unlikely), KVM will fall back to its unoptimized behavior, which _does_ honor the architectural behavior.
Pivot on 32-bit x2APIC IDs being enabled as that is required to take advantage of the hotplug hack (see kvm_apic_state_fixup()), i.e. won't break existing setups unless they are way, way off in the weeds.
And an entry in KVM's errata to document the hack. Alternatively, KVM could provide an actual x2APIC quirk and document the hack that way, but there's unlikely to ever be a use case for disabling the quirk. Go the errata route to avoid having to validate a quirk no one cares about.
--- Documentation/virt/kvm/x86/errata.rst | 11 ++++++ arch/x86/kvm/lapic.c | 50 ++++++++++++++++++++++----- 2 files changed, 52 insertions(+), 9 deletions(-)
Documentation/virt/kvm/x86/errata.rst +11 -0
@@ -37,3 +37,14 @@ Nested virtualization features ------------------------------ TBD + +x2APIC +------ +When KVM_X2APIC_API_USE_32BIT_IDS is enabled, KVM activates a hack/quirk that +allows sending events to a single vCPU using its x2APIC ID even if the target +vCPU has legacy xAPIC enabled, e.g. to bring up hotplugged vCPUs via INIT-SIPI +on VMs with > 255 vCPUs. A side effect of the quirk is that, if multiple vCPUs +have the same physical APIC ID, KVM will deliver events targeting that APIC ID +only to the vCPU with the lowest vCPU ID. If KVM_X2APIC_API_USE_32BIT_IDS is +not enabled, KVM follows x86 architecture when processing interrupts (all vCPUs +matching the target APIC ID receive the interrupt).
arch/x86/kvm/lapic.c +41 -9
67 lines not on this page · raw message
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 23/33 KVM: x86: Inhibit APICv/AVIC if the optimized physical map is disabled
In reply to Sean ChristophersonInhibit APICv/AVIC if the optimized physical map is disabled so that KVM KVM provides consistent APIC behavior if xAPIC IDs are aliased due to vcpu_id being truncated and the x2APIC hotplug hack isn't enabled. If the hotplug hack is disabled, events that are emulated by KVM will follow architectural behavior (all matching vCPUs receive events, even if the "match" is due to truncation), whereas APICv and AVIC will deliver events only to the first matching vCPU, i.e. the vCPU that matches without truncation.
Note, the "extra" inhibit is needed because KVM deliberately ignores mismatches due to truncation when applying the APIC_ID_MODIFIED inhibit so that large VMs (>255 vCPUs) can run with APICv/AVIC.
--- arch/x86/include/asm/kvm_host.h | 6 ++++++ arch/x86/kvm/lapic.c | 13 ++++++++++++- arch/x86/kvm/svm/avic.c | 1 + arch/x86/kvm/vmx/vmx.c | 1 + 4 files changed, 20 insertions(+), 1 deletion(-)
arch/x86/include/asm/kvm_host.h +6 -0
@@ -1174,6 +1174,12 @@ enum kvm_apicv_inhibit {*/ APICV_INHIBIT_REASON_BLOCKIRQ , +/* +* APICv is disabled because not all vCPUs have a 1:1 mapping between +* APIC ID and vCPU, _and_ KVM is not applying its x2APIC hotplug hack. +*/ + APICV_INHIBIT_REASON_PHYSICAL_ID_ALIASED, +/* * For simplicity, the APIC acceleration is inhibited * first time either APIC ID or APIC base are changed by the guest
arch/x86/kvm/lapic.c +12 -1
@@ -386,6 +386,16 @@ void kvm_recalculate_apic_map(struct kvm *kvm) cluster[ldr] = apic; } out: +/* +* The optimized map is effectively KVM's internal version of APICv, +* and all unwanted aliasing that results in disabling the optimized +* map also applies to APICv. +*/ +if (!new) +kvm_set_apicv_inhibit (kvm,APICV_INHIBIT_REASON_PHYSICAL_ID_ALIASED ); +else +kvm_clear_apicv_inhibit (kvm,APICV_INHIBIT_REASON_PHYSICAL_ID_ALIASED ); + old =rcu_dereference_protected (kvm->arch.apic_map,lockdep_is_held (&kvm->arch.apic_map_lock));rcu_assign_pointer (kvm->arch.apic_map, new);
@@ -2158,7 +2168,8 @@ static void kvm_lapic_xapic_id_updated(struct kvm_lapic *apic)/* * Deliberately truncate the vCPU ID when detecting a modified APIC ID * to avoid false positives if the vCPU ID, i.e. x2APIC ID, is a 32-bit -* value. +* value. If the wrap/truncation results in unwanted aliasing, APICv +* will be inhibited as part of updating KVM's optimized APIC maps. */ if (kvm_xapic_id (apic) == (u8 )apic->vcpu->vcpu_id)return ;
arch/x86/kvm/svm/avic.c +1 -0
@@ -965,6 +965,7 @@ bool avic_check_apicv_inhibit_reasons(enum kvm_apicv_inhibit reason)BIT (APICV_INHIBIT_REASON_PIT_REINJ ) |BIT (APICV_INHIBIT_REASON_BLOCKIRQ ) |BIT (APICV_INHIBIT_REASON_SEV ) | +BIT (APICV_INHIBIT_REASON_PHYSICAL_ID_ALIASED ) |BIT (APICV_INHIBIT_REASON_APIC_ID_MODIFIED ) |BIT (APICV_INHIBIT_REASON_APIC_BASE_MODIFIED );
arch/x86/kvm/vmx/vmx.c +1 -0
@@ -8029,6 +8029,7 @@ static bool vmx_check_apicv_inhibit_reasons(enum kvm_apicv_inhibit reason)BIT (APICV_INHIBIT_REASON_ABSENT ) |BIT (APICV_INHIBIT_REASON_HYPERV ) |BIT (APICV_INHIBIT_REASON_BLOCKIRQ ) | +BIT (APICV_INHIBIT_REASON_PHYSICAL_ID_ALIASED ) |BIT (APICV_INHIBIT_REASON_APIC_ID_MODIFIED ) |BIT (APICV_INHIBIT_REASON_APIC_BASE_MODIFIED );
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 24/33 KVM: SVM: Inhibit AVIC if vCPUs are aliased in logical mode
In reply to Sean ChristophersonInhibit SVM's AVIC if multiple vCPUs are aliased to the same logical ID. Architecturally, all CPUs whose logical ID matches the MDA are supposed to receive the interrupt; overwriting existing entries in AVIC's logical=>physical map can result in missed IPIs.
--- arch/x86/include/asm/kvm_host.h | 6 ++++++ arch/x86/kvm/lapic.c | 5 +++++ arch/x86/kvm/svm/avic.c | 3 ++- 3 files changed, 13 insertions(+), 1 deletion(-)
arch/x86/include/asm/kvm_host.h +6 -0
@@ -1218,6 +1218,12 @@ enum kvm_apicv_inhibit {* AVIC is disabled because SEV doesn't support it. */ APICV_INHIBIT_REASON_SEV , + +/* +* AVIC is disabled because not all vCPUs with a valid LDR have a 1:1 +* mapping between logical ID and vCPU. +*/ + APICV_INHIBIT_REASON_LOGICAL_ID_ALIASED, }; struct kvm_arch {
arch/x86/kvm/lapic.c +5 -0
@@ -396,6 +396,11 @@ void kvm_recalculate_apic_map(struct kvm *kvm)else kvm_clear_apicv_inhibit (kvm,APICV_INHIBIT_REASON_PHYSICAL_ID_ALIASED ); +if (!new || new->logical_mode ==KVM_APIC_MODE_MAP_DISABLED ) +kvm_set_apicv_inhibit (kvm,APICV_INHIBIT_REASON_LOGICAL_ID_ALIASED ); +else +kvm_clear_apicv_inhibit (kvm,APICV_INHIBIT_REASON_LOGICAL_ID_ALIASED ); + old =rcu_dereference_protected (kvm->arch.apic_map,lockdep_is_held (&kvm->arch.apic_map_lock));rcu_assign_pointer (kvm->arch.apic_map, new);
arch/x86/kvm/svm/avic.c +2 -1
@@ -967,7 +967,8 @@ bool avic_check_apicv_inhibit_reasons(enum kvm_apicv_inhibit reason)BIT (APICV_INHIBIT_REASON_SEV ) |BIT (APICV_INHIBIT_REASON_PHYSICAL_ID_ALIASED ) |BIT (APICV_INHIBIT_REASON_APIC_ID_MODIFIED ) | -BIT (APICV_INHIBIT_REASON_APIC_BASE_MODIFIED ); +BIT (APICV_INHIBIT_REASON_APIC_BASE_MODIFIED ) | +BIT (APICV_INHIBIT_REASON_LOGICAL_ID_ALIASED );return supported &BIT (reason); }
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 25/33 KVM: SVM: Always update local APIC on writes to logical dest register
In reply to Sean ChristophersonUpdate the vCPU's local (virtual) APIC on LDR writes even if the write "fails". The APIC needs to recalc the optimized logical map even if the LDR is invalid or zero, e.g. if the guest clears its LDR, the optimized map will be left as is and the vCPU will receive interrupts using its old LDR.
--- arch/x86/kvm/svm/avic.c | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-)
arch/x86/kvm/svm/avic.c +4 -7
@@ -573,7 +573,7 @@ static void avic_invalidate_logical_id_entry(struct kvm_vcpu *vcpu)clear_bit (AVIC_LOGICAL_ID_ENTRY_VALID_BIT , (unsigned long *)entry); } -static int avic_handle_ldr_update (struct kvm_vcpu *vcpu) +static void avic_handle_ldr_update (struct kvm_vcpu *vcpu) {int ret =0 ;struct vcpu_svm *svm =to_svm (vcpu);
@@ -582,10 +582,10 @@ static int avic_handle_ldr_update(struct kvm_vcpu *vcpu)/* AVIC does not support LDR update for x2APIC */ if (apic_x2apic_mode (vcpu->arch.apic)) -return 0 ; +return ;if (ldr == svm->ldr_reg) -return 0 ; +return ;avic_invalidate_logical_id_entry (vcpu);
@@ -594,8 +594,6 @@ static int avic_handle_ldr_update(struct kvm_vcpu *vcpu)if (!ret) svm->ldr_reg = ldr; - -return ret; }static void avic_handle_dfr_update (struct kvm_vcpu *vcpu)
@@ -617,8 +615,7 @@ static int avic_unaccel_trap_write(struct kvm_vcpu *vcpu)switch (offset) {case APIC_LDR : -if (avic_handle_ldr_update (vcpu)) -return 0 ; +avic_handle_ldr_update (vcpu);break ;case APIC_DFR :avic_handle_dfr_update (vcpu);
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 26/33 KVM: SVM: Update svm->ldr_reg cache even if LDR is "bad"
In reply to Sean ChristophersonUpdate SVM's cache of the LDR even if the new value is "bad". Leaving stale information in the cache can result in KVM missing updates and/or invalidating the wrong entry, e.g. if avic_invalidate_logical_id_entry() is triggered after a different vCPU has "claimed" the old LDR.
--- arch/x86/kvm/svm/avic.c | 14 ++++---------- 1 file changed, 4 insertions(+), 10 deletions(-)
arch/x86/kvm/svm/avic.c +4 -10
@@ -539,7 +539,7 @@ static u32 *avic_get_logical_id_entry(struct kvm_vcpu *vcpu, u32 ldr, bool flat)return &logical_apic_id_table[index]; } -static int avic_ldr_write (struct kvm_vcpu *vcpu,u8 g_physical_id,u32 ldr) +static void avic_ldr_write (struct kvm_vcpu *vcpu,u8 g_physical_id,u32 ldr) {bool flat;u32 *entry, new_entry;
@@ -547,15 +547,13 @@ static int avic_ldr_write(struct kvm_vcpu *vcpu, u8 g_physical_id, u32 ldr) flat =kvm_lapic_get_reg (vcpu->arch.apic,APIC_DFR ) ==APIC_DFR_FLAT ; entry =avic_get_logical_id_entry (vcpu, ldr, flat);if (!entry) -return -EINVAL ; +return ; new_entry =READ_ONCE (*entry); new_entry &= ~AVIC_LOGICAL_ID_ENTRY_GUEST_PHYSICAL_ID_MASK ; new_entry |= (g_physical_id &AVIC_LOGICAL_ID_ENTRY_GUEST_PHYSICAL_ID_MASK ); new_entry |=AVIC_LOGICAL_ID_ENTRY_VALID_MASK ;WRITE_ONCE (*entry, new_entry); - -return 0 ; }static void avic_invalidate_logical_id_entry (struct kvm_vcpu *vcpu)
@@ -575,7 +573,6 @@ static void avic_invalidate_logical_id_entry(struct kvm_vcpu *vcpu)static void avic_handle_ldr_update (struct kvm_vcpu *vcpu) { -int ret =0 ;struct vcpu_svm *svm =to_svm (vcpu);u32 ldr =kvm_lapic_get_reg (vcpu->arch.apic,APIC_LDR );u32 id =kvm_xapic_id (vcpu->arch.apic);
@@ -589,11 +586,8 @@ static void avic_handle_ldr_update(struct kvm_vcpu *vcpu)avic_invalidate_logical_id_entry (vcpu); -if (ldr) - ret =avic_ldr_write (vcpu, id, ldr); - -if (!ret) - svm->ldr_reg = ldr; + svm->ldr_reg = ldr; +avic_ldr_write (vcpu, id, ldr); }static void avic_handle_dfr_update (struct kvm_vcpu *vcpu)
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 27/33 KVM: SVM: Require logical ID to be power-of-2 for AVIC entry
In reply to Sean ChristophersonDo not modify AVIC's logical ID table if the logical ID portion of the LDR is not a power-of-2, i.e. if the LDR has multiple bits set. Taking only the first bit means that KVM will fail to match MDAs that intersect with "higher" bits in the "ID"
The "ID" acts as a bitmap, but is referred to as an ID because there's an implicit, unenforced "requirement" that software only set one bit. This edge case is arguably out-of-spec behavior, but KVM cleanly handles it in all other cases, e.g. the optimized logical map (and AVIC!) is also disabled in this scenario.
Refactor the code to consolidate the checks, and so that the code looks more like avic_kick_target_vcpus_fast().
--- arch/x86/kvm/svm/avic.c | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-)
arch/x86/kvm/svm/avic.c +15 -15
@@ -513,26 +513,26 @@ unsigned long avic_vcpu_get_apicv_inhibit_reasons(struct kvm_vcpu *vcpu)static u32 *avic_get_logical_id_entry (struct kvm_vcpu *vcpu,u32 ldr,bool flat) {struct kvm_svm *kvm_svm =to_kvm_svm (vcpu->kvm); -int index;u32 *logical_apic_id_table; -int dlid =GET_APIC_LOGICAL_ID (ldr); +u32 cluster, index; -if (!dlid) -return NULL ; + ldr =GET_APIC_LOGICAL_ID (ldr); -if (flat) {/* flat */ - index =ffs (dlid) -1 ; -if (index >7 ) +if (flat) { + cluster =0 ; + }else { + cluster = (ldr >>4 ); +if (cluster >=0xf )return NULL ; - }else {/* cluster */ -int cluster = (dlid &0xf0 ) >>4 ; -int apic =ffs (dlid &0x0f ) -1 ; - -if ((apic <0 ) || (apic >7 ) || - (cluster >=0xf )) -return NULL ; - index = (cluster <<2 ) + apic; + ldr &=0xf ; } +if (!ldr || !is_power_of_2 (ldr)) +return NULL ; + + index =__ffs (ldr); +if (WARN_ON_ONCE (index >7 )) +return NULL ; + index += (cluster <<2 ); logical_apic_id_table = (u32 *)page_address (kvm_svm->avic_logical_id_table_page);
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Re: [PATCH v5 27/33] KVM: SVM: Require logical ID to be power-of-2 for AVIC entry
Quoted 5 lines · Sean Christopherson
Do not modify AVIC's logical ID table if the logical ID portion of the LDR is not a power-of-2, i.e. if the LDR has multiple bits set. Taking only the first bit means that KVM will fail to match MDAs that intersect with "higher" bits in the "ID"
Quoted 8 lines
The "ID" acts as a bitmap, but is referred to as an ID because there's an implicit, unenforced "requirement" that software only set one bit. This edge case is arguably out-of-spec behavior, but KVM cleanly handles it in all other cases, e.g. the optimized logical map (and AVIC!) is also disabled in this scenario.
Refactor the code to consolidate the checks, and so that the code looks more like
avic_kick_target_vcpus_fast().
Very minor nitpick about the subject, it feels like it just changes something minor but it pretty much rewrites the avic_get_logical_id_entry.
When I bisected for the bug, this did confuse me a bit.
I don't have a good idea on how to call this patch so I won't object to the current subject to stay as well.
Best regards,
Maxim Levitsky
Quoted 45 lines
Fixes 18f40c53e10f ("svm: Add VMEXIT handlers for AVIC")Cc Suravee Suthikulpanit <[email protected]>Cc Maxim Levitsky <[email protected]>Signed-off-by Sean Christopherson <[email protected]>--- arch/x86/kvm/svm/avic.c | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-)arch/x86/kvm/svm/avic.c +8
-15@@ -513,26 +513,26 @@ unsigned long avic_vcpu_get_apicv_inhibit_reasons(struct kvm_vcpu *vcpu)static u32 *avic_get_logical_id_entry (struct kvm_vcpu *vcpu,u32 ldr,bool flat) {struct kvm_svm *kvm_svm =to_kvm_svm (vcpu->kvm); -int index;u32 *logical_apic_id_table; -int dlid =GET_APIC_LOGICAL_ID (ldr); +u32 cluster, index; -if (!dlid) -return NULL ; + ldr =GET_APIC_LOGICAL_ID (ldr); -if (flat) {/* flat */ - index =ffs (dlid) -1 ; -if (index >7 ) +if (flat) { + cluster =0 ; + }else { + cluster = (ldr >>4 ); +if (cluster >=0xf )return NULL ; - }else {/* cluster */ -int cluster = (dlid &0xf0 ) >>4 ; -int apic =ffs (dlid &0x0f ) -1 ; - -if ((apic <0 ) || (apic >7 ) || - (cluster >=0xf )) -return NULL ; - index = (cluster <<2 ) + apic; + ldr &=0xf ; }
arch/x86/kvm/svm/avic.c unsigned long avic_vcpu_get_apicv_inhibit_reasons(struct kvm_vcpu *vcpu) · line 538
Quoted 10 lines
arch/x86/kvm/svm/avic.c +7
-0+if (!ldr || !is_power_of_2 (ldr)) +return NULL ; + + index =__ffs (ldr); +if (WARN_ON_ONCE (index >7 )) +return NULL ; + index += (cluster <<2 ); logical_apic_id_table = (u32 *)page_address (kvm_svm->avic_logical_id_table_page);
Best regards,
Maxim Levitsky
Sean Christopherson
maintainerPATCH v5 28/33 KVM: SVM: Handle multiple logical targets in AVIC kick fastpath
In reply to Sean ChristophersonIterate over all target logical IDs in the AVIC kick fastpath instead of bailing if there is more than one target. Now that KVM inhibits AVIC if vCPUs aren't mapped 1:1 with logical IDs, each bit in the destination is guaranteed to match to at most one vCPU, i.e. iterating over the bitmap is guaranteed to kick each valid target exactly once.
--- arch/x86/kvm/svm/avic.c | 112 ++++++++++++++++++++++------------------ 1 file changed, 63 insertions(+), 49 deletions(-)
arch/x86/kvm/svm/avic.c +63 -49
@@ -327,6 +327,50 @@ static void avic_kick_vcpu(struct kvm_vcpu *vcpu, u32 icrl) icrl & APIC_VECTOR_MASK); } +static void avic_kick_vcpu_by_physical_id (struct kvm *kvm,u32 physical_id, +u32 icrl) +{ +/* +* KVM inhibits AVIC if any vCPU ID diverges from the vCPUs APIC ID, +* i.e. APIC ID == vCPU ID. +*/ +struct kvm_vcpu *target_vcpu =kvm_get_vcpu_by_id (kvm, physical_id); + +/* Once again, nothing to do if the target vCPU doesn't exist. */ +if (unlikely (!target_vcpu)) +return ; + +avic_kick_vcpu (target_vcpu, icrl); +} + +static void avic_kick_vcpu_by_logical_id (struct kvm *kvm,u32 *avic_logical_id_table, +u32 logid_index,u32 icrl) +{ +u32 physical_id; + +if (avic_logical_id_table) { +u32 logid_entry = avic_logical_id_table[logid_index]; + +/* Nothing to do if the logical destination is invalid. */ +if (unlikely (!(logid_entry &AVIC_LOGICAL_ID_ENTRY_VALID_MASK ))) +return ; + + physical_id = logid_entry & +AVIC_LOGICAL_ID_ENTRY_GUEST_PHYSICAL_ID_MASK ; + }else { +/* +* For x2APIC, the logical APIC ID is a read-only value that is +* derived from the x2APIC ID, thus the x2APIC ID can be found +* by reversing the calculation (stored in logid_index). Note, +* bits 31:20 of the x2APIC ID aren't propagated to the logical +* ID, but KVM limits the x2APIC ID limited to KVM_MAX_VCPU_IDS. +*/ + physical_id = logid_index; + } + +avic_kick_vcpu_by_physical_id (kvm, physical_id, icrl); +} +/* * A fast-path version of avic_kick_target_vcpus(), which attempts to match * destination APIC ID to vCPU without looping through all vCPUs.
@@ -334,11 +378,10 @@ static void avic_kick_vcpu(struct kvm_vcpu *vcpu, u32 icrl)static int avic_kick_target_vcpus_fast (struct kvm *kvm,struct kvm_lapic *source,u32 icrl,u32 icrh,u32 index) { -u32 l1_physical_id, dest; -struct kvm_vcpu *target_vcpu;int dest_mode = icrl &APIC_DEST_MASK ;int shorthand = icrl &APIC_SHORT_MASK ;struct kvm_svm *kvm_svm =to_kvm_svm (kvm); +u32 dest;if (shorthand !=APIC_DEST_NOSHORT )return -EINVAL ;
@@ -355,14 +398,14 @@ static int avic_kick_target_vcpus_fast(struct kvm *kvm, struct kvm_lapic *sourceif (!apic_x2apic_mode (source) && dest ==APIC_BROADCAST )return -EINVAL ; - l1_physical_id = dest; - -if (WARN_ON_ONCE (l1_physical_id != index)) +if (WARN_ON_ONCE (dest != index))return -EINVAL ; +avic_kick_vcpu_by_physical_id (kvm, dest, icrl); }else { -u32 bitmap, cluster; -int logid_index; +u32 *avic_logical_id_table; +unsigned long bitmap, i; +u32 cluster;if (apic_x2apic_mode (source)) {/* 16 bit dest mask, 16 bit cluster id */
@@ -382,50 +425,21 @@ static int avic_kick_target_vcpus_fast(struct kvm *kvm, struct kvm_lapic *sourceif (unlikely (!bitmap))return 0 ; -if (!is_power_of_2 (bitmap)) -/* multiple logical destinations, use slow path */ -return -EINVAL ; - - logid_index = cluster +__ffs (bitmap); - -if (apic_x2apic_mode (source)) { -/* -* For x2APIC, the logical APIC ID is a read-only value -* that is derived from the x2APIC ID, thus the x2APIC -* ID can be found by reversing the calculation (done -* above). Note, bits 31:20 of the x2APIC ID are not -* propagated to the logical ID, but KVM limits the -* x2APIC ID limited to KVM_MAX_VCPU_IDS. -*/ - l1_physical_id = logid_index; - }else { -u32 *avic_logical_id_table = -page_address (kvm_svm->avic_logical_id_table_page); - -u32 logid_entry = avic_logical_id_table[logid_index]; - -if (WARN_ON_ONCE (index != logid_index)) -return -EINVAL ; - -/* Nothing to do if the logical destination is invalid. */ -if (unlikely (!(logid_entry &AVIC_LOGICAL_ID_ENTRY_VALID_MASK ))) -return 0 ; - - l1_physical_id = logid_entry & -AVIC_LOGICAL_ID_ENTRY_GUEST_PHYSICAL_ID_MASK ; - } +if (apic_x2apic_mode (source)) + avic_logical_id_table =NULL ; +else + avic_logical_id_table =page_address (kvm_svm->avic_logical_id_table_page); + +/* +* AVIC is inhibited if vCPUs aren't mapped 1:1 with logical +* IDs, thus each bit in the destination is guaranteed to map +* to at most one vCPU. +*/ +for_each_set_bit (i, &bitmap,16 ) +avic_kick_vcpu_by_logical_id (kvm, avic_logical_id_table, + cluster + i, icrl); } -/* -* KVM inhibits AVIC if any vCPU ID diverges from the vCPUs APIC ID, -* i.e. APIC ID == vCPU ID. Once again, nothing to do if the target -* vCPU doesn't exist. -*/ - target_vcpu =kvm_get_vcpu_by_id (kvm, l1_physical_id); -if (unlikely (!target_vcpu)) -return 0 ; - -avic_kick_vcpu (target_vcpu, icrl);return 0 ; }
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 29/33 KVM: SVM: Ignore writes to Remote Read Data on AVIC write traps
In reply to Sean ChristophersonDrop writes to APIC_RRR, a.k.a. Remote Read Data Register, on AVIC unaccelerated write traps. The register is read-only and isn't emulated by KVM. Sending the register through kvm_apic_write_nodecode() will result in screaming when x2APIC is enabled due to the unexpected failure to retrieve the MSR (KVM expects that only "legal" accesses will trap).
--- arch/x86/kvm/svm/avic.c | 3 +++ 1 file changed, 3 insertions(+)
arch/x86/kvm/svm/avic.c +3 -0
@@ -628,6 +628,9 @@ static int avic_unaccel_trap_write(struct kvm_vcpu *vcpu)case APIC_DFR :avic_handle_dfr_update (vcpu);break ; +case APIC_RRR : +/* Ignore writes to Read Remote Data, it's read-only. */ +return 1 ;default :break ; }
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 30/33 Revert "KVM: SVM: Do not throw warning when calling avic_vcpu_load on a running vcpu"
In reply to Sean ChristophersonTurns out that some warnings exist for good reasons. Restore the warning in avic_vcpu_load() that guards against calling avic_vcpu_load() on a running vCPU now that KVM avoids doing so when switching between x2APIC and xAPIC. The entire point of the WARN is to highlight that KVM should not be reloading an AVIC.
Opportunistically convert the WARN_ON() to WARN_ON_ONCE() to avoid spamming the kernel if it does fire.
This reverts commit c0caeee65af3944b7b8abbf566e7cc1fae15c775.
--- arch/x86/kvm/svm/avic.c | 1 + 1 file changed, 1 insertion(+)
arch/x86/kvm/svm/avic.c +1 -0
@@ -1034,6 +1034,7 @@ void avic_vcpu_load(struct kvm_vcpu *vcpu, int cpu)return ; entry =READ_ONCE (*(svm->avic_physical_id_cache)); +WARN_ON_ONCE (entry &AVIC_PHYSICAL_ID_ENTRY_IS_RUNNING_MASK ); entry &= ~AVIC_PHYSICAL_ID_ENTRY_HOST_PHYSICAL_ID_MASK ; entry |= (h_physical_id &AVIC_PHYSICAL_ID_ENTRY_HOST_PHYSICAL_ID_MASK );
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 31/33 KVM: x86: Track required APICv inhibits with variable, not callback
In reply to Sean ChristophersonTrack the per-vendor required APICv inhibits with a variable instead of calling into vendor code every time KVM wants to query the set of required inhibits. The required inhibits are a property of the vendor's virtualization architecture, i.e. are 100% static.
Using a variable allows the compiler to inline the check, e.g. generate a single-uop TEST+Jcc, and thus eliminates any desire to avoid checking inhibits for performance reasons.
No functional change intended.
--- arch/x86/include/asm/kvm-x86-ops.h | 1 - arch/x86/include/asm/kvm_host.h | 1 + arch/x86/kvm/svm/avic.c | 19 ------------------- arch/x86/kvm/svm/svm.c | 2 +- arch/x86/kvm/svm/svm.h | 16 +++++++++++++++- arch/x86/kvm/vmx/vmx.c | 24 +++++++++++------------- arch/x86/kvm/x86.c | 2 +- 7 files changed, 29 insertions(+), 36 deletions(-)
arch/x86/include/asm/kvm-x86-ops.h +0 -1
@@ -76,7 +76,6 @@ KVM_X86_OP(set_nmi_mask) KVM_X86_OP(enable_nmi_window) KVM_X86_OP(enable_irq_window) KVM_X86_OP_OPTIONAL(update_cr8_intercept) -KVM_X86_OP(check_apicv_inhibit_reasons) KVM_X86_OP(refresh_apicv_exec_ctrl) KVM_X86_OP_OPTIONAL(hwapic_irr_update) KVM_X86_OP_OPTIONAL(hwapic_isr_update)
arch/x86/include/asm/kvm_host.h +1 -0
@@ -1623,6 +1623,7 @@ struct kvm_x86_ops {void (*enable_irq_window)(struct kvm_vcpu *vcpu);void (*update_cr8_intercept)(struct kvm_vcpu *vcpu,int tpr,int irr);bool (*check_apicv_inhibit_reasons)(enum kvm_apicv_inhibit reason); +const unsigned long required_apicv_inhibits;bool allow_apicv_in_x2apic_without_x2apic_virtualization;void (*refresh_apicv_exec_ctrl)(struct kvm_vcpu *vcpu);void (*hwapic_irr_update)(struct kvm_vcpu *vcpu,int max_irr);
arch/x86/kvm/svm/avic.c +0 -19
@@ -963,25 +963,6 @@ int avic_pi_update_irte(struct kvm *kvm, unsigned int host_irq,return ret; } -bool avic_check_apicv_inhibit_reasons (enum kvm_apicv_inhibit reason) -{ -ulong supported =BIT (APICV_INHIBIT_REASON_DISABLE ) | -BIT (APICV_INHIBIT_REASON_ABSENT ) | -BIT (APICV_INHIBIT_REASON_HYPERV ) | -BIT (APICV_INHIBIT_REASON_NESTED ) | -BIT (APICV_INHIBIT_REASON_IRQWIN ) | -BIT (APICV_INHIBIT_REASON_PIT_REINJ ) | -BIT (APICV_INHIBIT_REASON_BLOCKIRQ ) | -BIT (APICV_INHIBIT_REASON_SEV ) | -BIT (APICV_INHIBIT_REASON_PHYSICAL_ID_ALIASED ) | -BIT (APICV_INHIBIT_REASON_APIC_ID_MODIFIED ) | -BIT (APICV_INHIBIT_REASON_APIC_BASE_MODIFIED ) | -BIT (APICV_INHIBIT_REASON_LOGICAL_ID_ALIASED ); - -return supported &BIT (reason); -} - -static inline int avic_update_iommu_vcpu_affinity (struct kvm_vcpu *vcpu,int cpu,bool r) {
arch/x86/kvm/svm/svm.c +1 -1
@@ -4773,8 +4773,8 @@ static struct kvm_x86_ops svm_x86_ops __initdata = { .update_cr8_intercept = svm_update_cr8_intercept, .set_virtual_apic_mode = avic_refresh_virtual_apic_mode, .refresh_apicv_exec_ctrl = avic_refresh_apicv_exec_ctrl, - .check_apicv_inhibit_reasons = avic_check_apicv_inhibit_reasons, .apicv_post_state_restore = avic_apicv_post_state_restore, + .required_apicv_inhibits = AVIC_REQUIRED_APICV_INHIBITS, .get_exit_info = svm_get_exit_info,
arch/x86/kvm/svm/svm.h +15 -1
@@ -621,6 +621,21 @@ void svm_switch_vmcb(struct vcpu_svm *svm, struct kvm_vmcb_info *target_vmcb);extern struct kvm_x86_nested_ops svm_nested_ops;/* avic.c */ +#define AVIC_REQUIRED_APICV_INHIBITS \ +( \ + BIT(APICV_INHIBIT_REASON_DISABLE) | \ + BIT(APICV_INHIBIT_REASON_ABSENT) | \ + BIT(APICV_INHIBIT_REASON_HYPERV) | \ + BIT(APICV_INHIBIT_REASON_NESTED) | \ + BIT(APICV_INHIBIT_REASON_IRQWIN) | \ + BIT(APICV_INHIBIT_REASON_PIT_REINJ) | \ + BIT(APICV_INHIBIT_REASON_BLOCKIRQ) | \ + BIT(APICV_INHIBIT_REASON_SEV) | \ + BIT(APICV_INHIBIT_REASON_PHYSICAL_ID_ALIASED) | \ + BIT(APICV_INHIBIT_REASON_APIC_ID_MODIFIED) | \ + BIT(APICV_INHIBIT_REASON_APIC_BASE_MODIFIED) | \ + BIT(APICV_INHIBIT_REASON_LOGICAL_ID_ALIASED) \ +)bool avic_hardware_setup (struct kvm_x86_ops *ops);int avic_ga_log_notifier (u32 ga_tag);
@@ -634,7 +649,6 @@ void avic_vcpu_load(struct kvm_vcpu *vcpu, int cpu);void avic_vcpu_put (struct kvm_vcpu *vcpu);void avic_apicv_post_state_restore (struct kvm_vcpu *vcpu);void avic_refresh_apicv_exec_ctrl (struct kvm_vcpu *vcpu); -bool avic_check_apicv_inhibit_reasons (enum kvm_apicv_inhibit reason);int avic_pi_update_irte (struct kvm *kvm,unsigned int host_irq,uint32_t guest_irq,bool set);void avic_vcpu_blocking (struct kvm_vcpu *vcpu);
arch/x86/kvm/vmx/vmx.c +11 -13
@@ -8023,18 +8023,16 @@ static void vmx_hardware_unsetup(void)free_kvm_area (); } -static bool vmx_check_apicv_inhibit_reasons (enum kvm_apicv_inhibit reason) -{ -ulong supported =BIT (APICV_INHIBIT_REASON_DISABLE ) | -BIT (APICV_INHIBIT_REASON_ABSENT ) | -BIT (APICV_INHIBIT_REASON_HYPERV ) | -BIT (APICV_INHIBIT_REASON_BLOCKIRQ ) | -BIT (APICV_INHIBIT_REASON_PHYSICAL_ID_ALIASED ) | -BIT (APICV_INHIBIT_REASON_APIC_ID_MODIFIED ) | -BIT (APICV_INHIBIT_REASON_APIC_BASE_MODIFIED ); - -return supported &BIT (reason); -} +#define VMX_REQUIRED_APICV_INHIBITS \ +( \ + BIT(APICV_INHIBIT_REASON_DISABLE)| \ + BIT(APICV_INHIBIT_REASON_ABSENT) | \ + BIT(APICV_INHIBIT_REASON_HYPERV) | \ + BIT(APICV_INHIBIT_REASON_BLOCKIRQ) | \ + BIT(APICV_INHIBIT_REASON_PHYSICAL_ID_ALIASED) | \ + BIT(APICV_INHIBIT_REASON_APIC_ID_MODIFIED) | \ + BIT(APICV_INHIBIT_REASON_APIC_BASE_MODIFIED) \ +)static void vmx_vm_destroy (struct kvm *kvm) {
@@ -8118,7 +8116,7 @@ static struct kvm_x86_ops vmx_x86_ops __initdata = { .refresh_apicv_exec_ctrl = vmx_refresh_apicv_exec_ctrl, .load_eoi_exitmap = vmx_load_eoi_exitmap, .apicv_post_state_restore = vmx_apicv_post_state_restore, - .check_apicv_inhibit_reasons = vmx_check_apicv_inhibit_reasons, + .required_apicv_inhibits = VMX_REQUIRED_APICV_INHIBITS, .hwapic_irr_update = vmx_hwapic_irr_update, .hwapic_isr_update = vmx_hwapic_isr_update, .guest_apic_has_interrupt = vmx_guest_apic_has_interrupt,
arch/x86/kvm/x86.c +1 -1
@@ -10112,7 +10112,7 @@ void __kvm_set_or_clear_apicv_inhibit(struct kvm *kvm,lockdep_assert_held_write (&kvm->arch.apicv_update_lock); -if (!static_call (kvm_x86_check_apicv_inhibit_reasons)(reason)) +if (!(kvm_x86_ops.required_apicv_inhibits &BIT (reason)))return ; old = new = kvm->arch.apicv_inhibit_reasons;
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Sean Christopherson
maintainerPATCH v5 32/33 KVM: x86: Allow APICv APIC ID inhibit to be cleared
In reply to Sean ChristophersonFrom: Greg Edwards <[email protected]>
Legacy kernels prior to commit 4399c03c6780 ("x86/apic: Remove verify_local_APIC()") write the APIC ID of the boot CPU twice to verify a functioning local APIC. This results in APIC acceleration inhibited on these kernels for reason APICV_INHIBIT_REASON_APIC_ID_MODIFIED.
Allow the APICV_INHIBIT_REASON_APIC_ID_MODIFIED inhibit reason to be cleared if/when all APICs in xAPIC mode set their APIC ID back to the expected vcpu_id value.
Fold the functionality previously in kvm_lapic_xapic_id_updated() into kvm_recalculate_apic_map(), as this allows examining all APICs in one pass.
--- arch/x86/kvm/lapic.c | 41 +++++++++++++++-------------------------- 1 file changed, 15 insertions(+), 26 deletions(-)
arch/x86/kvm/lapic.c +15 -26
@@ -236,6 +236,7 @@ void kvm_recalculate_apic_map(struct kvm *kvm)struct kvm_vcpu *vcpu;unsigned long i;u32 max_id =255 ;/* enough space for any xAPIC ID */ +bool xapic_id_mismatch = false;/* Read kvm->arch.apic_map_dirty before kvm->arch.apic_map. */ if (atomic_read_acquire (&kvm->arch.apic_map_dirty) ==CLEAN )
@@ -285,6 +286,15 @@ void kvm_recalculate_apic_map(struct kvm *kvm) xapic_id =kvm_xapic_id (apic); x2apic_id =kvm_x2apic_id (apic); +/* +* Deliberately truncate the vCPU ID when detecting a mismatched +* APIC ID to avoid false positives if the vCPU ID, i.e. x2APIC +* ID, is a 32-bit value. Any unwanted aliasing due to +* truncation results will be detected below. +*/ +if (!apic_x2apic_mode (apic) && xapic_id != (u8 )vcpu->vcpu_id) + xapic_id_mismatch = true; +/* * Apply KVM's hotplug hack if userspace has enable 32-bit APIC * IDs. Allow sending events to vCPUs by their x2APIC ID even
@@ -401,6 +411,11 @@ void kvm_recalculate_apic_map(struct kvm *kvm)else kvm_clear_apicv_inhibit (kvm,APICV_INHIBIT_REASON_LOGICAL_ID_ALIASED ); +if (xapic_id_mismatch) +kvm_set_apicv_inhibit (kvm,APICV_INHIBIT_REASON_APIC_ID_MODIFIED ); +else +kvm_clear_apicv_inhibit (kvm,APICV_INHIBIT_REASON_APIC_ID_MODIFIED ); + old =rcu_dereference_protected (kvm->arch.apic_map,lockdep_is_held (&kvm->arch.apic_map_lock));rcu_assign_pointer (kvm->arch.apic_map, new);
@@ -2160,28 +2175,6 @@ static void apic_manage_nmi_watchdog(struct kvm_lapic *apic, u32 lvt0_val) } } -static void kvm_lapic_xapic_id_updated (struct kvm_lapic *apic) -{ -struct kvm *kvm = apic->vcpu->kvm; - -if (!kvm_apic_hw_enabled (apic)) -return ; - -if (KVM_BUG_ON (apic_x2apic_mode (apic), kvm)) -return ; - -/* -* Deliberately truncate the vCPU ID when detecting a modified APIC ID -* to avoid false positives if the vCPU ID, i.e. x2APIC ID, is a 32-bit -* value. If the wrap/truncation results in unwanted aliasing, APICv -* will be inhibited as part of updating KVM's optimized APIC maps. -*/ -if (kvm_xapic_id (apic) == (u8 )apic->vcpu->vcpu_id) -return ; - -kvm_set_apicv_inhibit (apic->vcpu->kvm,APICV_INHIBIT_REASON_APIC_ID_MODIFIED ); -} -static int get_lvt_index (u32 reg) {if (reg ==APIC_LVTCMCI )
@@ -2202,7 +2195,6 @@ static int kvm_lapic_reg_write(struct kvm_lapic *apic, u32 reg, u32 val)case APIC_ID :/* Local APIC ID */ if (!apic_x2apic_mode (apic)) {kvm_apic_set_xapic_id (apic, val >>24 ); -kvm_lapic_xapic_id_updated (apic); }else { ret =1 ; }
@@ -2923,9 +2915,6 @@ int kvm_apic_set_state(struct kvm_vcpu *vcpu, struct kvm_lapic_state *s) }memcpy (vcpu->arch.apic->regs, s->regs,sizeof (*s)); -if (!apic_x2apic_mode (apic)) -kvm_lapic_xapic_id_updated (apic); -atomic_set_release (&apic->vcpu->kvm->arch.apic_map_dirty,DIRTY );kvm_recalculate_apic_map (vcpu->kvm);kvm_apic_set_version (vcpu);
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Re: [PATCH v5 32/33] KVM: x86: Allow APICv APIC ID inhibit to be cleared
Quoted 101 lines · Sean Christopherson
From: Greg Edwards <[email protected]>
Legacy kernels prior to commit
4399c03c6780("x86/apic: Removeverify_local_APIC()") write the APIC ID of the boot CPU twice to verify a functioning local APIC. This results in APIC acceleration inhibited on these kernels for reasonAPICV_INHIBIT_REASON_APIC_ID_MODIFIED.Allow the
APICV_INHIBIT_REASON_APIC_ID_MODIFIEDinhibit reason to be cleared if/when all APICs in xAPIC mode set their APIC ID back to the expectedvcpu_idvalue.Fold the functionality previously in
kvm_lapic_xapic_id_updated()intokvm_recalculate_apic_map(), as this allows examining all APICs in one pass.Fixes 3743c2f02517 ("KVM: x86: inhibit APICv/AVIC on changes to APIC ID or APIC base")Signed-off-by Greg Edwards <[email protected]>Signed-off-by Sean Christopherson <[email protected]>--- arch/x86/kvm/lapic.c | 41 +++++++++++++++-------------------------- 1 file changed, 15 insertions(+), 26 deletions(-)arch/x86/kvm/lapic.c +15
-23@@ -236,6 +236,7 @@ void kvm_recalculate_apic_map(struct kvm *kvm)struct kvm_vcpu *vcpu;unsigned long i;u32 max_id =255 ;/* enough space for any xAPIC ID */ +bool xapic_id_mismatch = false;/* Read kvm->arch.apic_map_dirty before kvm->arch.apic_map. */ if (atomic_read_acquire (&kvm->arch.apic_map_dirty) ==CLEAN )@@ -285,6 +286,15 @@ void kvm_recalculate_apic_map(struct kvm *kvm) xapic_id =kvm_xapic_id (apic); x2apic_id =kvm_x2apic_id (apic); +/* +* Deliberately truncate the vCPU ID when detecting a mismatched +* APIC ID to avoid false positives if the vCPU ID, i.e. x2APIC +* ID, is a 32-bit value. Any unwanted aliasing due to +* truncation results will be detected below. +*/ +if (!apic_x2apic_mode (apic) && xapic_id != (u8 )vcpu->vcpu_id) + xapic_id_mismatch = true; +/* * Apply KVM's hotplug hack if userspace has enable 32-bit APIC * IDs. Allow sending events to vCPUs by their x2APIC ID even @@ -401,6 +411,11 @@ void kvm_recalculate_apic_map(struct kvm *kvm)else kvm_clear_apicv_inhibit (kvm,APICV_INHIBIT_REASON_LOGICAL_ID_ALIASED ); +if (xapic_id_mismatch) +kvm_set_apicv_inhibit (kvm,APICV_INHIBIT_REASON_APIC_ID_MODIFIED ); +else +kvm_clear_apicv_inhibit (kvm,APICV_INHIBIT_REASON_APIC_ID_MODIFIED ); + old =rcu_dereference_protected (kvm->arch.apic_map,lockdep_is_held (&kvm->arch.apic_map_lock));rcu_assign_pointer (kvm->arch.apic_map, new);@@ -2160,28 +2175,6 @@ static void apic_manage_nmi_watchdog(struct kvm_lapic *apic, u32 lvt0_val) } } -static void kvm_lapic_xapic_id_updated (struct kvm_lapic *apic) -{ -struct kvm *kvm = apic->vcpu->kvm; - -if (!kvm_apic_hw_enabled (apic)) -return ; - -if (KVM_BUG_ON (apic_x2apic_mode (apic), kvm)) -return ; - -/* -* Deliberately truncate the vCPU ID when detecting a modified APIC ID -* to avoid false positives if the vCPU ID, i.e. x2APIC ID, is a 32-bit -* value. If the wrap/truncation results in unwanted aliasing, APICv -* will be inhibited as part of updating KVM's optimized APIC maps. -*/ -if (kvm_xapic_id (apic) == (u8 )apic->vcpu->vcpu_id) -return ; - -kvm_set_apicv_inhibit (apic->vcpu->kvm,APICV_INHIBIT_REASON_APIC_ID_MODIFIED ); -} -static int get_lvt_index (u32 reg) {if (reg ==APIC_LVTCMCI )@@ -2202,7 +2195,6 @@ static int kvm_lapic_reg_write(struct kvm_lapic *apic, u32 reg, u32 val)case APIC_ID :/* Local APIC ID */ if (!apic_x2apic_mode (apic)) {kvm_apic_set_xapic_id (apic, val >>24 ); -kvm_lapic_xapic_id_updated (apic); }else { ret =1 ; }
arch/x86/kvm/lapic.c int kvm_apic_set_state(struct kvm_vcpu *vcpu, struct kvm_lapic_state *s) · line 2920
Quoted 9 lines
arch/x86/kvm/lapic.c +0
-3@@ -2923,9 +2915,6 @@ int kvm_apic_set_state(struct kvm_vcpu *vcpu, struct kvm_lapic_state *s) }memcpy (vcpu->arch.apic->regs, s->regs,sizeof (*s)); -if (!apic_x2apic_mode (apic)) -kvm_lapic_xapic_id_updated (apic); -atomic_set_release (&apic->vcpu->kvm->arch.apic_map_dirty,DIRTY );kvm_recalculate_apic_map (vcpu->kvm);kvm_apic_set_version (vcpu);
Best regards,
Maxim Levitsky
Sean Christopherson
maintainerPATCH v5 33/33 KVM: x86: Add helpers to recalc physical vs. logical optimized APIC maps
In reply to Sean ChristophersonMove the guts of kvm_recalculate_apic_map()'s main loop to two separate helpers to handle recalculating the physical and logical pieces of the optimized map. Having 100+ lines of code in the for-loop makes it hard to understand what is being calculated where.
No functional change intended.
--- arch/x86/kvm/lapic.c | 250 +++++++++++++++++++++++-------------------- 1 file changed, 133 insertions(+), 117 deletions(-)
arch/x86/kvm/lapic.c +133 -117
@@ -218,6 +218,134 @@ static void kvm_apic_map_free(struct rcu_head *rcu)kvfree (map); } +static int kvm_recalculate_phys_map (struct kvm_apic_map *new, +struct kvm_vcpu *vcpu, +bool *xapic_id_mismatch) +{ +struct kvm_lapic *apic = vcpu->arch.apic; +u32 x2apic_id =kvm_x2apic_id (apic); +u32 xapic_id =kvm_xapic_id (apic); +u32 physical_id; + +/* +* Deliberately truncate the vCPU ID when detecting a mismatched APIC +* ID to avoid false positives if the vCPU ID, i.e. x2APIC ID, is a +* 32-bit value. Any unwanted aliasing due to truncation results will +* be detected below. +*/ +if (!apic_x2apic_mode (apic) && xapic_id != (u8 )vcpu->vcpu_id) + *xapic_id_mismatch = true; + +/* +* Apply KVM's hotplug hack if userspace has enable 32-bit APIC IDs. +* Allow sending events to vCPUs by their x2APIC ID even if the target +* vCPU is in legacy xAPIC mode, and silently ignore aliased xAPIC IDs +* (the x2APIC ID is truncated to 8 bits, causing IDs > 0xff to wrap +* and collide). +* +* Honor the architectural (and KVM's non-optimized) behavior if +* userspace has not enabled 32-bit x2APIC IDs. Each APIC is supposed +* to process messages independently. If multiple vCPUs have the same +* effective APIC ID, e.g. due to the x2APIC wrap or because the guest +* manually modified its xAPIC IDs, events targeting that ID are +* supposed to be recognized by all vCPUs with said ID. +*/ +if (vcpu->kvm->arch.x2apic_format) { +/* See also kvm_apic_match_physical_addr(). */ +if ((apic_x2apic_mode (apic) || x2apic_id >0xff ) && + x2apic_id <= new->max_apic_id) + new->phys_map[x2apic_id] = apic; + +if (!apic_x2apic_mode (apic) && !new->phys_map[xapic_id]) + new->phys_map[xapic_id] = apic; + }else { +/* +* Disable the optimized map if the physical APIC ID is already +* mapped, i.e. is aliased to multiple vCPUs. The optimized +* map requires a strict 1:1 mapping between IDs and vCPUs. +*/ +if (apic_x2apic_mode (apic)) + physical_id = x2apic_id; +else + physical_id = xapic_id; + +if (new->phys_map[physical_id]) +return -EINVAL ; + + new->phys_map[physical_id] = apic; + } + +return 0 ; +} + +static void kvm_recalculate_logical_map (struct kvm_apic_map *new, +struct kvm_vcpu *vcpu) +{ +struct kvm_lapic *apic = vcpu->arch.apic; +enum kvm_apic_logical_mode logical_mode; +struct kvm_lapic **cluster; +u16 mask; +u32 ldr; + +if (new->logical_mode ==KVM_APIC_MODE_MAP_DISABLED ) +return ; + +if (!kvm_apic_sw_enabled (apic)) +return ; + + ldr =kvm_lapic_get_reg (apic,APIC_LDR ); +if (!ldr) +return ; + +if (apic_x2apic_mode (apic)) { + logical_mode =KVM_APIC_MODE_X2APIC ; + }else { + ldr =GET_APIC_LOGICAL_ID (ldr); +if (kvm_lapic_get_reg (apic,APIC_DFR ) ==APIC_DFR_FLAT ) + logical_mode =KVM_APIC_MODE_XAPIC_FLAT ; +else + logical_mode =KVM_APIC_MODE_XAPIC_CLUSTER ; + } + +/* +* To optimize logical mode delivery, all software-enabled APICs must +* be configured for the same mode. +*/ +if (new->logical_mode ==KVM_APIC_MODE_SW_DISABLED ) { + new->logical_mode = logical_mode; + }else if (new->logical_mode != logical_mode) { + new->logical_mode =KVM_APIC_MODE_MAP_DISABLED ; +return ; + } + +/* +* In x2APIC mode, the LDR is read-only and derived directly from the +* x2APIC ID, thus is guaranteed to be addressable. KVM reuses +* kvm_apic_map.phys_map to optimize logical mode x2APIC interrupts by +* reversing the LDR calculation to get cluster of APICs, i.e. no +* additional work is required. +*/ +if (apic_x2apic_mode (apic)) { +WARN_ON_ONCE (ldr !=kvm_apic_calc_x2apic_ldr (kvm_x2apic_id (apic))); +return ; + } + +if (WARN_ON_ONCE (!kvm_apic_map_get_logical_dest (new, ldr, + &cluster, &mask))) { + new->logical_mode =KVM_APIC_MODE_MAP_DISABLED ; +return ; + } + +if (!mask) +return ; + + ldr =ffs (mask) -1 ; +if (!is_power_of_2 (mask) || cluster[ldr]) + new->logical_mode =KVM_APIC_MODE_MAP_DISABLED ; +else + cluster[ldr] = apic; +} +/* * CLEAN -> DIRTY and UPDATE_IN_PROGRESS -> DIRTY changes happen without a lock. *
@@ -272,128 +400,16 @@ void kvm_recalculate_apic_map(struct kvm *kvm) new->logical_mode =KVM_APIC_MODE_SW_DISABLED ;kvm_for_each_vcpu (i, vcpu, kvm) { -struct kvm_lapic *apic = vcpu->arch.apic; -struct kvm_lapic **cluster; -enum kvm_apic_logical_mode logical_mode; -u32 x2apic_id, physical_id; -u16 mask; -u32 ldr; -u8 xapic_id; -if (!kvm_apic_present (vcpu))continue ; - xapic_id =kvm_xapic_id (apic); - x2apic_id =kvm_x2apic_id (apic); - -/* -* Deliberately truncate the vCPU ID when detecting a mismatched -* APIC ID to avoid false positives if the vCPU ID, i.e. x2APIC -* ID, is a 32-bit value. Any unwanted aliasing due to -* truncation results will be detected below. -*/ -if (!apic_x2apic_mode (apic) && xapic_id != (u8 )vcpu->vcpu_id) - xapic_id_mismatch = true; - -/* -* Apply KVM's hotplug hack if userspace has enable 32-bit APIC -* IDs. Allow sending events to vCPUs by their x2APIC ID even -* if the target vCPU is in legacy xAPIC mode, and silently -* ignore aliased xAPIC IDs (the x2APIC ID is truncated to 8 -* bits, causing IDs > 0xff to wrap and collide). -* -* Honor the architectural (and KVM's non-optimized) behavior -* if userspace has not enabled 32-bit x2APIC IDs. Each APIC -* is supposed to process messages independently. If multiple -* vCPUs have the same effective APIC ID, e.g. due to the -* x2APIC wrap or because the guest manually modified its xAPIC -* IDs, events targeting that ID are supposed to be recognized -* by all vCPUs with said ID. -*/ -if (kvm->arch.x2apic_format) { -/* See also kvm_apic_match_physical_addr(). */ -if ((apic_x2apic_mode (apic) || x2apic_id >0xff ) && - x2apic_id <= new->max_apic_id) - new->phys_map[x2apic_id] = apic; - -if (!apic_x2apic_mode (apic) && !new->phys_map[xapic_id]) - new->phys_map[xapic_id] = apic; - }else { -/* -* Disable the optimized map if the physical APIC ID is -* already mapped, i.e. is aliased to multiple vCPUs. -* The optimized map requires a strict 1:1 mapping -* between IDs and vCPUs. -*/ -if (apic_x2apic_mode (apic)) - physical_id = x2apic_id; -else - physical_id = xapic_id; - -if (new->phys_map[physical_id]) { -kvfree (new); - new =NULL ; - goto out; - } - new->phys_map[physical_id] = apic; - } - -if (new->logical_mode ==KVM_APIC_MODE_MAP_DISABLED || - !kvm_apic_sw_enabled (apic)) -continue ; - - ldr =kvm_lapic_get_reg (apic,APIC_LDR ); -if (!ldr) -continue ; - -if (apic_x2apic_mode (apic)) { - logical_mode =KVM_APIC_MODE_X2APIC ; - }else { - ldr =GET_APIC_LOGICAL_ID (ldr); -if (kvm_lapic_get_reg (apic,APIC_DFR ) ==APIC_DFR_FLAT ) - logical_mode =KVM_APIC_MODE_XAPIC_FLAT ; -else - logical_mode =KVM_APIC_MODE_XAPIC_CLUSTER ; +if (kvm_recalculate_phys_map (new, vcpu, &xapic_id_mismatch)) { +kvfree (new); + new =NULL ; + goto out; } -/* -* To optimize logical mode delivery, all software-enabled APICs must -* be configured for the same mode. -*/ -if (new->logical_mode ==KVM_APIC_MODE_SW_DISABLED ) { - new->logical_mode = logical_mode; - }else if (new->logical_mode != logical_mode) { - new->logical_mode =KVM_APIC_MODE_MAP_DISABLED ; -continue ; - } - -/* -* In x2APIC mode, the LDR is read-only and derived directly -* from the x2APIC ID, thus is guaranteed to be addressable. -* KVM reuses kvm_apic_map.phys_map to optimize logical mode -* x2APIC interrupts by reversing the LDR calculation to get -* cluster of APICs, i.e. no additional work is required. -*/ -if (apic_x2apic_mode (apic)) { -WARN_ON_ONCE (ldr !=kvm_apic_calc_x2apic_ldr (x2apic_id)); -continue ; - } - -if (WARN_ON_ONCE (!kvm_apic_map_get_logical_dest (new, ldr, - &cluster, &mask))) { - new->logical_mode =KVM_APIC_MODE_MAP_DISABLED ; -continue ; - } - -if (!mask) -continue ; - - ldr =ffs (mask) -1 ; -if (!is_power_of_2 (mask) || cluster[ldr]) { - new->logical_mode =KVM_APIC_MODE_MAP_DISABLED ; -continue ; - } - cluster[ldr] = apic; +kvm_recalculate_logical_map (new, vcpu); } out:/*
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Re: [PATCH v5 33/33] KVM: x86: Add helpers to recalc physical vs. logical optimized APIC maps
Quoted 64 lines · Sean Christopherson
Move the guts of kvm_recalculate_apic_map()'s main loop to two separate helpers to handle recalculating the physical and logical pieces of the optimized map. Having 100+ lines of code in the for-loop makes it hard to understand what is being calculated where.
No functional change intended.
Suggested-by Maxim Levitsky <[email protected]>Signed-off-by Sean Christopherson <[email protected]>--- arch/x86/kvm/lapic.c | 250 +++++++++++++++++++++++-------------------- 1 file changed, 133 insertions(+), 117 deletions(-)arch/x86/kvm/lapic.c +43
-0@@ -218,6 +218,134 @@ static void kvm_apic_map_free(struct rcu_head *rcu)kvfree (map); } +static int kvm_recalculate_phys_map (struct kvm_apic_map *new, +struct kvm_vcpu *vcpu, +bool *xapic_id_mismatch) +{ +struct kvm_lapic *apic = vcpu->arch.apic; +u32 x2apic_id =kvm_x2apic_id (apic); +u32 xapic_id =kvm_xapic_id (apic); +u32 physical_id; + +/* +* Deliberately truncate the vCPU ID when detecting a mismatched APIC +* ID to avoid false positives if the vCPU ID, i.e. x2APIC ID, is a +* 32-bit value. Any unwanted aliasing due to truncation results will +* be detected below. +*/ +if (!apic_x2apic_mode (apic) && xapic_id != (u8 )vcpu->vcpu_id) + *xapic_id_mismatch = true; + +/* +* Apply KVM's hotplug hack if userspace has enable 32-bit APIC IDs. +* Allow sending events to vCPUs by their x2APIC ID even if the target +* vCPU is in legacy xAPIC mode, and silently ignore aliased xAPIC IDs +* (the x2APIC ID is truncated to 8 bits, causing IDs > 0xff to wrap +* and collide). +* +* Honor the architectural (and KVM's non-optimized) behavior if +* userspace has not enabled 32-bit x2APIC IDs. Each APIC is supposed +* to process messages independently. If multiple vCPUs have the same +* effective APIC ID, e.g. due to the x2APIC wrap or because the guest +* manually modified its xAPIC IDs, events targeting that ID are +* supposed to be recognized by all vCPUs with said ID. +*/ +if (vcpu->kvm->arch.x2apic_format) { +/* See also kvm_apic_match_physical_addr(). */ +if ((apic_x2apic_mode (apic) || x2apic_id >0xff ) && + x2apic_id <= new->max_apic_id) + new->phys_map[x2apic_id] = apic; + +if (!apic_x2apic_mode (apic) && !new->phys_map[xapic_id]) + new->phys_map[xapic_id] = apic; + }else { +/* +* Disable the optimized map if the physical APIC ID is already
arch/x86/kvm/lapic.c static void kvm_apic_map_free(struct rcu_head *rcu) · line 273
Quoted 10 lines
arch/x86/kvm/lapic.c +10
-0+* mapped, i.e. is aliased to multiple vCPUs. The optimized +* map requires a strict 1:1 mapping between IDs and vCPUs. +*/ +if (apic_x2apic_mode (apic)) + physical_id = x2apic_id; +else + physical_id = xapic_id; + +if (new->phys_map[physical_id]) +return -EINVAL ;
Very small nitpick: -EINVAL feels like redundant here,
I'll say just return -1 or returning boolean would be a tiny bit better. But this really doesn't matter much.
Quoted 202 lines
arch/x86/kvm/lapic.c +79
-111+ + new->phys_map[physical_id] = apic; + } + +return 0 ; +} + +static void kvm_recalculate_logical_map (struct kvm_apic_map *new, +struct kvm_vcpu *vcpu) +{ +struct kvm_lapic *apic = vcpu->arch.apic; +enum kvm_apic_logical_mode logical_mode; +struct kvm_lapic **cluster; +u16 mask; +u32 ldr; + +if (new->logical_mode ==KVM_APIC_MODE_MAP_DISABLED ) +return ; + +if (!kvm_apic_sw_enabled (apic)) +return ; + + ldr =kvm_lapic_get_reg (apic,APIC_LDR ); +if (!ldr) +return ; + +if (apic_x2apic_mode (apic)) { + logical_mode =KVM_APIC_MODE_X2APIC ; + }else { + ldr =GET_APIC_LOGICAL_ID (ldr); +if (kvm_lapic_get_reg (apic,APIC_DFR ) ==APIC_DFR_FLAT ) + logical_mode =KVM_APIC_MODE_XAPIC_FLAT ; +else + logical_mode =KVM_APIC_MODE_XAPIC_CLUSTER ; + } + +/* +* To optimize logical mode delivery, all software-enabled APICs must +* be configured for the same mode. +*/ +if (new->logical_mode ==KVM_APIC_MODE_SW_DISABLED ) { + new->logical_mode = logical_mode; + }else if (new->logical_mode != logical_mode) { + new->logical_mode =KVM_APIC_MODE_MAP_DISABLED ; +return ; + } + +/* +* In x2APIC mode, the LDR is read-only and derived directly from the +* x2APIC ID, thus is guaranteed to be addressable. KVM reuses +* kvm_apic_map.phys_map to optimize logical mode x2APIC interrupts by +* reversing the LDR calculation to get cluster of APICs, i.e. no +* additional work is required. +*/ +if (apic_x2apic_mode (apic)) { +WARN_ON_ONCE (ldr !=kvm_apic_calc_x2apic_ldr (kvm_x2apic_id (apic))); +return ; + } + +if (WARN_ON_ONCE (!kvm_apic_map_get_logical_dest (new, ldr, + &cluster, &mask))) { + new->logical_mode =KVM_APIC_MODE_MAP_DISABLED ; +return ; + } + +if (!mask) +return ; + + ldr =ffs (mask) -1 ; +if (!is_power_of_2 (mask) || cluster[ldr]) + new->logical_mode =KVM_APIC_MODE_MAP_DISABLED ; +else + cluster[ldr] = apic; +} +/* * CLEAN -> DIRTY and UPDATE_IN_PROGRESS -> DIRTY changes happen without a lock. * @@ -272,128 +400,16 @@ void kvm_recalculate_apic_map(struct kvm *kvm) new->logical_mode =KVM_APIC_MODE_SW_DISABLED ;kvm_for_each_vcpu (i, vcpu, kvm) { -struct kvm_lapic *apic = vcpu->arch.apic; -struct kvm_lapic **cluster; -enum kvm_apic_logical_mode logical_mode; -u32 x2apic_id, physical_id; -u16 mask; -u32 ldr; -u8 xapic_id; -if (!kvm_apic_present (vcpu))continue ; - xapic_id =kvm_xapic_id (apic); - x2apic_id =kvm_x2apic_id (apic); - -/* -* Deliberately truncate the vCPU ID when detecting a mismatched -* APIC ID to avoid false positives if the vCPU ID, i.e. x2APIC -* ID, is a 32-bit value. Any unwanted aliasing due to -* truncation results will be detected below. -*/ -if (!apic_x2apic_mode (apic) && xapic_id != (u8 )vcpu->vcpu_id) - xapic_id_mismatch = true; - -/* -* Apply KVM's hotplug hack if userspace has enable 32-bit APIC -* IDs. Allow sending events to vCPUs by their x2APIC ID even -* if the target vCPU is in legacy xAPIC mode, and silently -* ignore aliased xAPIC IDs (the x2APIC ID is truncated to 8 -* bits, causing IDs > 0xff to wrap and collide). -* -* Honor the architectural (and KVM's non-optimized) behavior -* if userspace has not enabled 32-bit x2APIC IDs. Each APIC -* is supposed to process messages independently. If multiple -* vCPUs have the same effective APIC ID, e.g. due to the -* x2APIC wrap or because the guest manually modified its xAPIC -* IDs, events targeting that ID are supposed to be recognized -* by all vCPUs with said ID. -*/ -if (kvm->arch.x2apic_format) { -/* See also kvm_apic_match_physical_addr(). */ -if ((apic_x2apic_mode (apic) || x2apic_id >0xff ) && - x2apic_id <= new->max_apic_id) - new->phys_map[x2apic_id] = apic; - -if (!apic_x2apic_mode (apic) && !new->phys_map[xapic_id]) - new->phys_map[xapic_id] = apic; - }else { -/* -* Disable the optimized map if the physical APIC ID is -* already mapped, i.e. is aliased to multiple vCPUs. -* The optimized map requires a strict 1:1 mapping -* between IDs and vCPUs. -*/ -if (apic_x2apic_mode (apic)) - physical_id = x2apic_id; -else - physical_id = xapic_id; - -if (new->phys_map[physical_id]) { -kvfree (new); - new =NULL ; - goto out; - } - new->phys_map[physical_id] = apic; - } - -if (new->logical_mode ==KVM_APIC_MODE_MAP_DISABLED || - !kvm_apic_sw_enabled (apic)) -continue ; - - ldr =kvm_lapic_get_reg (apic,APIC_LDR ); -if (!ldr) -continue ; - -if (apic_x2apic_mode (apic)) { - logical_mode =KVM_APIC_MODE_X2APIC ; - }else { - ldr =GET_APIC_LOGICAL_ID (ldr); -if (kvm_lapic_get_reg (apic,APIC_DFR ) ==APIC_DFR_FLAT ) - logical_mode =KVM_APIC_MODE_XAPIC_FLAT ; -else - logical_mode =KVM_APIC_MODE_XAPIC_CLUSTER ; +if (kvm_recalculate_phys_map (new, vcpu, &xapic_id_mismatch)) { +kvfree (new); + new =NULL ; + goto out; } -/* -* To optimize logical mode delivery, all software-enabled APICs must -* be configured for the same mode. -*/ -if (new->logical_mode ==KVM_APIC_MODE_SW_DISABLED ) { - new->logical_mode = logical_mode; - }else if (new->logical_mode != logical_mode) { - new->logical_mode =KVM_APIC_MODE_MAP_DISABLED ; -continue ; - } - -/* -* In x2APIC mode, the LDR is read-only and derived directly -* from the x2APIC ID, thus is guaranteed to be addressable. -* KVM reuses kvm_apic_map.phys_map to optimize logical mode -* x2APIC interrupts by reversing the LDR calculation to get -* cluster of APICs, i.e. no additional work is required. -*/ -if (apic_x2apic_mode (apic)) { -WARN_ON_ONCE (ldr !=kvm_apic_calc_x2apic_ldr (x2apic_id)); -continue ; - } - -if (WARN_ON_ONCE (!kvm_apic_map_get_logical_dest (new, ldr, - &cluster, &mask))) { - new->logical_mode =KVM_APIC_MODE_MAP_DISABLED ; -continue ; - } - -if (!mask) -continue ; -
arch/x86/kvm/lapic.c void kvm_recalculate_apic_map(struct kvm *kvm) · line 415
Quoted 10 lines
arch/x86/kvm/lapic.c +1
-6- ldr =ffs (mask) -1 ; -if (!is_power_of_2 (mask) || cluster[ldr]) { - new->logical_mode =KVM_APIC_MODE_MAP_DISABLED ; -continue ; - } - cluster[ldr] = apic; +kvm_recalculate_logical_map (new, vcpu); } out:/*
Looks good, much cleaner now.
Best regards,
Maxim Levitsky
Quoted 119 lines · Sean Christopherson
Paolo,
This is a wholesale (and hopefully a drop-in) replacement for the patches in
kvm-lapic-fix-and-cleanup. The changes for " KVM: x86: Inhibit APIC memslot if x2APIC and AVIC are enabled" in v5 are relatively minor, but it led to multiple conflicts in later patches, i.e. a patch-to-be-squashed wasn't going to work. Let me know if you've already done a lot of massaging on your side, shouldn't be too difficult to generate patches to go on top.The first half or so patches fix semi-urgent, real-world relevant APICv and AVIC bugs.
The second half fixes a variety of AVIC and optimized APIC map bugs where KVM doesn't play nice with various edge cases that are architecturally legal(ish), but are unlikely to occur in most real world scenarios
v5:
- Fix even more bugs! [Greg]
- Collect reviews. [Maxim]
- Don't use an inhibit flag for hybrid AVIC. [Maxim]
- Fix an LDR cluster calc goof in the AVIC code. [Maxim]
- Drop a redundant "ldr == 0" check. [Maxim]
- Add helpers for logical vs. physical optimized map calcs. [Maxim]v4:
- https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Flore.kernel.org%2Fall%2F20221001005915.2041642-1-seanjc%40google.com&data=05%7C01%7Csuravee.suthikulpanit%40amd.com%7C266a9838dbb74b5ac6fb08daef832f65%7C3dd8961fe4884e608e11a82d994e183d%7C0%7C0%7C638085643969977723%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&sdata=%2BUOZ4e1Ov%2BwPkKTSe81P1tPUtxpEr2uddkhMn73kLhQ%3D&reserved=0
- Fix more bugs! [Alejandro]
- Delete APIC memslot to inhibit xAVIC acceleration when x2APIC is
enabled on AMD/SVM instead of using a "partial" inihbit. [Maxim]v3:
- https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Flore.kernel.org%2Fall%2F20220920233134.940511-1-seanjc%40google.com&data=05%7C01%7Csuravee.suthikulpanit%40amd.com%7C266a9838dbb74b5ac6fb08daef832f65%7C3dd8961fe4884e608e11a82d994e183d%7C0%7C0%7C638085643969977723%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&sdata=usZ0dheeVyhBJxLP2ahA1hUlN64gwAPooWR9jnQcRyQ%3D&reserved=0
- Collect reviews. [Paolo]
- Drop "partial" x2APIC inhibit and instead delete the memslot.
[Maxim, Suravee]
- Skip logical mode updates for x2APIC, which just reuses the
phys_mapwith some clever logic. [Suravee]
- Add a fix for "nodecode write" traps. [Alejandro]v2:
- https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Flore.kernel.org%2Fall%2F20220903002254.2411750-1-seanjc%40google.com&data=05%7C01%7Csuravee.suthikulpanit%40amd.com%7C266a9838dbb74b5ac6fb08daef832f65%7C3dd8961fe4884e608e11a82d994e183d%7C0%7C0%7C638085643969977723%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&sdata=olaieXGtEfg8K6wwNHjHRa0aRit0npXnoxTmnfR%2FhqQ%3D&reserved=0
- Collect reviews. [Li, Maxim]
- Disable only MMIO access when x2APIC is enabled (instead of disabling
all of AVIC). [Maxim]
- Inhibit AVIC when logical IDs are aliased. [Maxim]
- Tweak name ofset_virtual_apic_mode()hook. [Maxim]
- Straight up revert logical ID fastpath mess. [Maxim]
- Reword changelog about skipping vCPU during logical setup. [Maxim]
- Fix LDR updates on AVIC. [Maxim?]
- Fix a nasty ISR caching bug.
- Flush TLB when activating AVIC.Greg Edwards (1):
KVM: x86: Allow APICv APIC ID inhibit to be clearedSean Christopherson (31):
KVM: x86: Blindly get current x2APIC reg value on "nodecode write"
traps
KVM: x86: Purge "highest ISR" cache when updating APICv state
KVM: SVM: Flush the "current" TLB when activating AVIC
KVM: SVM: Process ICR on AVIC IPI delivery failure due to invalid
target
KVM: x86: Don't inhibit APICv/AVIC on xAPIC ID "change" if APIC is
disabled
KVM: x86: Don't inhibit APICv/AVIC if xAPIC ID mismatch is due to32-bit IDKVM: SVM: Don't put/load AVIC when setting virtual APIC mode
KVM: x86: Handle APICv updates for APIC "mode" changes via request
KVM: x86: Move APIC access page helper to common x86 code
KVM: x86: Inhibit APIC memslot if x2APIC and AVIC are enabled
KVM: SVM: Replace "avic_mode" enum with "x2avic_enabled" boolean
KVM: SVM: Compute dest based on sender's x2APIC status for AVIC kick Revert "KVM: SVM: Use target APIC ID to complete x2AVIC IRQs when
possible"
KVM: SVM: Document that vCPU ID == APIC ID in AVIC kick fastpatch
KVM: SVM: Add helper to perform final AVIC "kick" of single vCPU
KVM: x86: Explicitly skip optimized logical map setup if vCPU's LDR==0
KVM: x86: Explicitly track all possibilities for APIC map's logical
modes
KVM: x86: Skip redundant x2APIC logical mode optimized cluster setup
KVM: x86: Disable APIC logical map if logical ID covers multiple MDAs
KVM: x86: Disable APIC logical map if vCPUs are aliased in logical
mode
KVM: x86: Honor architectural behavior for aliased 8-bit APIC IDs
KVM: x86: Inhibit APICv/AVIC if the optimized physical map is disabled
KVM: SVM: Inhibit AVIC if vCPUs are aliased in logical mode
KVM: SVM: Always update local APIC on writes to logical dest register
KVM: SVM: Updatesvm->ldr_regcache even if LDR is "bad"
KVM: SVM: Require logical ID to be power-of-2 for AVIC entry
KVM: SVM: Handle multiple logical targets in AVIC kick fastpath
KVM: SVM: Ignore writes to Remote Read Data on AVIC write traps Revert "KVM: SVM: Do not throw warning when callingavic_vcpu_loadon
a running vcpu"
KVM: x86: Track required APICv inhibits with variable, not callback
KVM: x86: Add helpers to recalc physical vs. logical optimized APIC
mapsSuravee Suthikulpanit (1):
KVM: SVM: Fix x2APIC Logical ID calculation for
avic_kick_target_vcpus_fastDocumentation/virt/kvm/x86/errata.rst | 11 + arch/x86/include/asm/kvm-x86-ops.h | 1 - arch/x86/include/asm/kvm_host.h | 52 +++- arch/x86/kvm/lapic.c | 319 +++++++++++++++++----- arch/x86/kvm/lapic.h | 2 + arch/x86/kvm/svm/avic.c | 372 ++++++++++++-------------- arch/x86/kvm/svm/nested.c | 2 +- arch/x86/kvm/svm/svm.c | 8 +- arch/x86/kvm/svm/svm.h | 27 +- arch/x86/kvm/vmx/vmx.c | 58 +--- arch/x86/kvm/x86.c | 29 +- 11 files changed, 524 insertions(+), 357 deletions(-)
Quoted 1 line
base-commit:
c04ec04c0d15a51aa33660be175ed978beb8de0c
For AMD AVIC / x2AVIC:
Thanks,
Suravee