NMI for CVM in OpenHCL

openhcl/underhill_core/src/worker.rs

@@ -2300,6 +2300,11 @@ async fn new_underhill_vm(
         );
     }
 
+    // Set the callback in GET to trigger the debug interrupt.
+    let p = partition.clone();
+    let debug_interrupt_callback = move |vtl: u8| p.assert_debug_interrupt(vtl);
+    get_client.set_debug_interrupt_callback(Box::new(debug_interrupt_callback));
+
     let mut input_distributor = InputDistributor::new(remote_console_cfg.input);
     resolver.add_async_resolver::<KeyboardInputHandleKind, _, MultiplexedInputHandle, _>(
         input_distributor.client().clone(),

openhcl/virt_mshv_vtl/src/lib.rs

@@ -103,6 +103,7 @@ use user_driver::DmaClient;
 use virt::IsolationType;
 use virt::PartitionCapabilities;
 use virt::VpIndex;
+use virt::X86Partition;
 use virt::irqcon::IoApicRouting;
 use virt::irqcon::MsiRequest;
 use virt::x86::apic_software_device::ApicSoftwareDevices;
@@ -844,7 +845,7 @@ impl virt::Partition for UhPartition {
     }
 }
 
-impl virt::X86Partition for UhPartition {
+impl X86Partition for UhPartition {
     fn ioapic_routing(&self) -> Arc<dyn IoApicRouting> {
         self.inner.clone()
     }
@@ -1929,6 +1930,22 @@ impl UhPartition {
         }
     }
 
+    /// Trigger the LINT1 interrupt vector on the LAPIC of the BSP.
+    pub fn assert_debug_interrupt(&self, _vtl: u8) {
+        #[cfg(guest_arch = "x86_64")]
+        const LINT_INDEX_1: u8 = 1;
+        #[cfg(guest_arch = "x86_64")]
+        match self.inner.isolation {
+            IsolationType::Snp => {
+                tracing::error!(?_vtl, "Debug interrupts cannot be injected into SNP VMs",);
+            }
+            _ => {
+                let bsp_index = VpIndex::new(0);
+                self.pulse_lint(bsp_index, Vtl::try_from(_vtl).unwrap(), LINT_INDEX_1)
+            }
+        }
+    }
+
     /// Enables or disables the PM timer assist.
     pub fn set_pm_timer_assist(&self, port: Option<u16>) -> Result<(), HvError> {
         self.inner.hcl.set_pm_timer_assist(port)

vm/devices/get/get_protocol/src/lib.rs

@@ -94,6 +94,7 @@ open_enum! {
         MODIFY_VTL2_SETTINGS_REV1 = 6,
         // --- GE ---
         BATTERY_STATUS = 7,
+        INJECT_DEBUG_INTERRUPT = 8,
     }
 }
 
@@ -1759,6 +1760,16 @@ impl BatteryStatusNotification {
     }
 }
 
+#[repr(C)]
+#[derive(Copy, Clone, Debug, IntoBytes, FromBytes, Immutable, KnownLayout)]
+pub struct InjectDebugInterruptNotification {
+    pub message_header: HeaderGuestNotification,
+    pub vtl: u8,
+    pub _pad: u8,
+}
+
+const_assert_eq!(6, size_of::<InjectDebugInterruptNotification>());
+
 #[bitfield(u64)]
 #[derive(IntoBytes, FromBytes, Immutable, KnownLayout)]
 pub struct CreateRamGpaRangeFlags {

vm/devices/get/guest_emulation_transport/src/client.rs

@@ -400,6 +400,12 @@ impl GuestEmulationTransportClient {
             .notify(msg::Msg::SetGpaAllocator(gpa_allocator));
     }
 
+    /// Set the the callback to trigger the debug interrupt.
+    pub fn set_debug_interrupt_callback(&mut self, callback: Box<dyn Fn(u8) + Send + Sync>) {
+        self.control
+            .notify(msg::Msg::SetDebugInterruptCallback(callback));
+    }
+
     /// Send the attestation request to the IGVM agent on the host.
     pub async fn igvm_attest(
         &self,

vm/devices/get/guest_emulation_transport/src/process_loop.rs

@@ -191,6 +191,8 @@ pub(crate) mod msg {
         Inspect(inspect::Deferred),
         /// Store the gpa allocator to be used for attestation.
         SetGpaAllocator(Arc<dyn DmaClient>),
+        /// Store the callback to trigger the debug interrupt.
+        SetDebugInterruptCallback(Box<dyn Fn(u8) + Send + Sync>),
 
         // Late bound receivers for Guest Notifications
         /// Take the late-bound GuestRequest receiver for Generation Id updates.
@@ -493,6 +495,8 @@ pub(crate) struct ProcessLoop<T: RingMem> {
     #[inspect(skip)]
     secondary_host_requests_read_send: mesh::Sender<Vec<u8>>,
     gpa_allocator: Option<Arc<dyn DmaClient>>,
+    #[inspect(skip)]
+    set_debug_interrupt: Option<Box<dyn Fn(u8) + Send + Sync>>,
     stats: Stats,
 
     guest_notification_listeners: GuestNotificationListeners,
@@ -700,6 +704,7 @@ impl<T: RingMem> ProcessLoop<T> {
                 battery_status: GuestNotificationSender::new(),
             },
             gpa_allocator: None,
+            set_debug_interrupt: None,
         }
     }
 
@@ -1029,6 +1034,9 @@ impl<T: RingMem> ProcessLoop<T> {
             Msg::SetGpaAllocator(gpa_allocator) => {
                 self.gpa_allocator = Some(gpa_allocator);
             }
+            Msg::SetDebugInterruptCallback(callback) => {
+                self.set_debug_interrupt = Some(callback);
+            }
 
             // Late bound receivers for Guest Notifications
             Msg::TakeVtl2SettingsReceiver(req) => req.handle_sync(|()| {
@@ -1244,8 +1252,8 @@ impl<T: RingMem> ProcessLoop<T> {
     ) -> Result<(), FatalError> {
         use get_protocol::GuestNotifications;
 
-        // Version must be latest. Give up if not.
-        if header.message_version != get_protocol::MessageVersions::HEADER_VERSION_1 {
+        // Version must be at least version 1.
+        if header.message_version < get_protocol::MessageVersions::HEADER_VERSION_1 {
             tracing::error!(
                 msg = ?buf,
                 version = ?header.message_version,
@@ -1287,6 +1295,9 @@ impl<T: RingMem> ProcessLoop<T> {
             GuestNotifications::BATTERY_STATUS => {
                 self.handle_battery_status_notification(read_guest_notification(id, buf)?)?;
             }
+            GuestNotifications::INJECT_DEBUG_INTERRUPT => {
+                self.handle_debug_interrupt_notification(read_guest_notification(id, buf)?)?;
+            }
             invalid_notification => {
                 tracing::error!(
                     ?invalid_notification,
@@ -1489,6 +1500,30 @@ impl<T: RingMem> ProcessLoop<T> {
             })
     }
 
+    fn handle_debug_interrupt_notification(
+        &mut self,
+        notification: get_protocol::InjectDebugInterruptNotification,
+    ) -> Result<(), FatalError> {
+        tracing::debug!(
+            "Received inject debug interrupt notification, vtl = {}",
+            notification.vtl,
+        );
+
+        if notification.vtl != 0 {
+            tracing::error!(
+                ?notification.vtl,
+                "Debug interrupts can only be injected into VTL 0",
+            );
+        } else {
+            // Trigger the LINT1 interrupt vector on the LAPIC of the BSP.
+            if let Some(callback) = self.set_debug_interrupt.as_ref() {
+                callback(notification.vtl)
+            }
+        }
+
+        Ok(())
+    }
+
     fn complete_modify_vtl2_settings(
         &mut self,
         result: Result<(), RpcError<Vec<Vtl2SettingsErrorInfo>>>,