x86/apic: Handle EOI writes for Secure AVIC guests

Secure AVIC accelerates the guest's EOI MSR writes for edge-triggered
interrupts.

For level-triggered interrupts, EOI MSR writes trigger a #VC exception with
an SVM_EXIT_AVIC_UNACCELERATED_ACCESS error code. To complete EOI handling,
the #VC exception handler would need to trigger a GHCB protocol MSR write
event to notify the hypervisor about completion of the level-triggered
interrupt.  Hypervisor notification is required for cases like emulated
IO-APIC, to complete and clear interrupt in the IO-APIC's interrupt state.

However, #VC exception handling adds extra performance overhead for APIC
register writes. In addition, for Secure AVIC, some unaccelerated APIC
register MSR writes are trapped, whereas others are faulted.

This results in additional complexity in #VC exception handling for
unaccelerated APIC MSR accesses. So, directly do a GHCB protocol based APIC
EOI MSR write from apic->eoi() callback for level-triggered interrupts.

Use WRMSR for edge-triggered interrupts, so that hardware re-evaluates any
pending interrupt which can be delivered to the guest vCPU. For
level-triggered interrupts, re-evaluation happens on return from VMGEXIT
corresponding to the GHCB event for APIC EOI MSR write.

Signed-off-by: Neeraj Upadhyay <Neeraj.Upadhyay@amd.com>
Signed-off-by: Borislav Petkov (AMD) <bp@alien8.de>
Reviewed-by: Tianyu Lan <tiala@microsoft.com>
Link: https://lore.kernel.org/20250828111654.208987-1-Neeraj.Upadhyay@amd.com

diff --git a/arch/x86/kernel/apic/x2apic_savic.c b/arch/x86/kernel/apic/x2apic_savic.c
index b6d6e7a69c89de23be9b565c5a1207be900d7de6..d76faeaced83eeb6e45e4759b9523f5b709b25fb 100644 (file)
--- a/arch/x86/kernel/apic/x2apic_savic.c
+++ b/arch/x86/kernel/apic/x2apic_savic.c
@@ -301,6 +301,35 @@ static void savic_update_vector(unsigned int cpu, unsigned int vector, bool set)
        update_vector(cpu, SAVIC_ALLOWED_IRR, vector, set);
 }
 
+static void savic_eoi(void)
+{
+       unsigned int cpu;
+       int vec;
+
+       cpu = raw_smp_processor_id();
+       vec = apic_find_highest_vector(get_reg_bitmap(cpu, APIC_ISR));
+       if (WARN_ONCE(vec == -1, "EOI write while no active interrupt in APIC_ISR"))
+               return;
+
+       /* Is level-triggered interrupt? */
+       if (apic_test_vector(vec, get_reg_bitmap(cpu, APIC_TMR))) {
+               update_vector(cpu, APIC_ISR, vec, false);
+               /*
+                * Propagate the EOI write to the hypervisor for level-triggered
+                * interrupts. Return to the guest from GHCB protocol event takes
+                * care of re-evaluating interrupt state.
+                */
+               savic_ghcb_msr_write(APIC_EOI, 0);
+       } else {
+               /*
+                * Hardware clears APIC_ISR and re-evaluates the interrupt state
+                * to determine if there is any pending interrupt which can be
+                * delivered to CPU.
+                */
+               native_apic_msr_eoi();
+       }
+}
+
 static void savic_setup(void)
 {
        void *ap = this_cpu_ptr(savic_page);
@@ -380,7 +409,7 @@ static struct apic apic_x2apic_savic __ro_after_init = {
 
        .read                           = savic_read,
        .write                          = savic_write,
-       .eoi                            = native_apic_msr_eoi,
+       .eoi                            = savic_eoi,
        .icr_read                       = native_x2apic_icr_read,
        .icr_write                      = savic_icr_write,