Hoist the XCOMP_BV read into MSHV vCPU creation (#1912)

Currently, every MSHV vCPU reset calls `get_xsave` to copy XCOMP_BV into
the zeroed XSAVE area. This PR hoists that read into vCPU creation, and
every reset reuses the value. This saves one hypercall per
`Sandbox::restore()`.

This is safe because XCOMP_BV depends only on the partition's XSAVE
features, which are fixed at partition initialization and unaffected by
guest state or snapshots.

## Benchmarks

`mshv3`: AMD EPYC 7763, Linux 6.6 MSHV.

| Benchmark | Before | After | Change |
|---|---|---|---|
| `snapshots/restore/default` | 87.9 µs | 66.0 µs | −25% |
| `snapshots/restore/small` | 88.6 µs | 66.5 µs | −25% |
| `snapshots/restore/medium` | 99.4 µs | 77.9 µs | −22% |
| `guest_calls/call_with_restore/default` | 156.8 µs | 133.9 µs | −15% |
| `guest_calls/call_with_restore/medium` | 165.5 µs | 140.6 µs | −15% |
| `sandboxes/create_initialized/default` | 1.48 ms | 1.53 ms | +3% |
| `sandboxes/sandbox_from_snapshot/default` | 598 µs | 624 µs | +4% |

Each restore saves one `get_xsave` hypercall, about 22 µs. Each vCPU
creation makes that hypercall once.

Signed-off-by: Ludvig Liljenberg <4257730+ludfjig@users.noreply.github.com>

Author: ludfjig

CHANGELOG.md

@@ -61,6 +61,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
   architecture-independent exception handling hooks. The new
   interfaces are significantly more liminited, but more portable; they
   will be extended in the future.
+* MSHV: vCPU creation reads the partition's XSAVE format once. This removes
+  one hypercall from every restore.
 
 ### Removed
 * `RunPool` and the run-specific `AllocError::InvalidAlign` variant.

src/hyperlight_host/src/hypervisor/virtual_machine/mod.rs

@@ -110,9 +110,9 @@ pub(crate) enum HypervisorType {
 }
 
 /// Minimum XSAVE buffer size: 512 bytes legacy region + 64 bytes header.
-/// Only used by MSHV and WHP which use compacted XSAVE format and need to
+/// Only used by WHP which uses compacted XSAVE format and needs to
 /// validate buffer size before accessing XCOMP_BV.
-#[cfg(all(target_arch = "x86_64", any(mshv3, target_os = "windows")))]
+#[cfg(all(target_arch = "x86_64", target_os = "windows"))]
 pub(crate) const XSAVE_MIN_SIZE: usize = 576;
 
 /// Standard XSAVE buffer size (4KB) used by KVM and MSHV.

src/hyperlight_host/src/hypervisor/virtual_machine/mshv/x86_64.rs

@@ -48,7 +48,7 @@ use crate::hypervisor::virtual_machine::XSAVE_BUFFER_SIZE;
 use crate::hypervisor::virtual_machine::x86_64::hw_interrupts::TimerThread;
 use crate::hypervisor::virtual_machine::{
     CreateVmError, MapMemoryError, RegisterError, RunVcpuError, UnmapMemoryError, VirtualMachine,
-    VmExit, XSAVE_MIN_SIZE,
+    VmExit,
 };
 use crate::mem::memory_region::{MemoryRegion, MemoryRegionFlags};
 #[cfg(feature = "trace_guest")]
@@ -155,6 +155,8 @@ pub(crate) struct MshvVm {
     #[cfg(not(feature = "hw-interrupts"))]
     vm_fd: VmFd,
     vcpu_fd: VcpuFd,
+    /// XCOMP_BV from the XSAVE header. Fixed for the life of the partition.
+    xcomp_bv: [u8; 8],
     /// Handle to the background timer (if started).
     #[cfg(feature = "hw-interrupts")]
     timer: Option<TimerThread>,
@@ -209,12 +211,19 @@ impl MshvVm {
         #[cfg(feature = "hw-interrupts")]
         Self::init_lapic(&vcpu_fd)?;
 
+        let xsave = vcpu_fd
+            .get_xsave()
+            .map_err(|e| CreateVmError::InitializeVm(e.into()))?;
+        let mut xcomp_bv = [0u8; 8];
+        xcomp_bv.copy_from_slice(&xsave.buffer[520..528]);
+
         Ok(Self {
             #[cfg(feature = "hw-interrupts")]
             vm_fd: Arc::new(vm_fd),
             #[cfg(not(feature = "hw-interrupts"))]
             vm_fd,
             vcpu_fd,
+            xcomp_bv,
             #[cfg(feature = "hw-interrupts")]
             timer: None,
         })
@@ -569,22 +578,10 @@ impl VirtualMachine for MshvVm {
     }
 
     fn reset_xsave(&self) -> std::result::Result<(), RegisterError> {
-        let current_xsave = self
-            .vcpu_fd
-            .get_xsave()
-            .map_err(|e| RegisterError::GetXsave(e.into()))?;
-        if current_xsave.buffer.len() < XSAVE_MIN_SIZE {
-            // Minimum: 512 legacy + 64 header
-            return Err(RegisterError::XsaveSizeMismatch {
-                expected: XSAVE_MIN_SIZE as u32,
-                actual: current_xsave.buffer.len() as u32,
-            });
-        }
-
         let mut buf = XSave::default(); // default is zeroed 4KB buffer
 
         // Copy XCOMP_BV (offset 520-527) - preserves feature mask + compacted bit
-        buf.buffer[520..528].copy_from_slice(&current_xsave.buffer[520..528]);
+        buf.buffer[520..528].copy_from_slice(&self.xcomp_bv);
 
         // XSAVE area layout from Intel SDM Vol. 1 Section 13.4.1:
         // - Bytes 0-1: FCW (x87 FPU Control Word)