Set mxcsr explicity on kvm and add tests

Signed-off-by: James Sturtevant <jsturtevant@gmail.com>

src/hyperlight_host/src/hypervisor/kvm.rs

@@ -579,7 +579,8 @@ impl Hypervisor for KVMDriver {
         };
         self.vcpu_fd.set_regs(&regs)?;
 
-        // reset fpu state
+        // note kvm set_fpu doesn't actually set or read the mxcsr value
+        // https://elixir.bootlin.com/linux/v6.16/source/arch/x86/kvm/x86.c#L12229
         let fpu = kvm_fpu {
             fcw: FP_CONTROL_WORD_DEFAULT,
             ftwx: FP_TAG_WORD_DEFAULT,
@@ -588,6 +589,24 @@ impl Hypervisor for KVMDriver {
         };
         self.vcpu_fd.set_fpu(&fpu)?;
 
+        // Set MXCSR from XSAVE (MXCSR is at byte offset 24 -> u32 index 6)
+        // Locations are from 
+        // AMD64 Architecture Programmer's Manual, Volume 2
+        // 11.5.10 Mode-Specific XSAVE/XRSTOR State Management
+        let mut xsave = match self.vcpu_fd.get_xsave() {
+            Ok(xsave) => xsave,
+            Err(e) => {
+                return Err(new_error!("Could not write guest registers: {:?}", e));
+            }
+        };
+
+        xsave.region[6] = MXCSR_DEFAULT;
+        unsafe {
+            self.vcpu_fd
+                .set_xsave(&xsave)
+                .map_err(|e| new_error!("Could not write guest registers: {:?}", e))?
+        };
+
         // run
         VirtualCPU::run(
             self.as_mut_hypervisor(),

src/hyperlight_host/src/sandbox/initialized_multi_use.rs

@@ -486,6 +486,7 @@ mod tests {
     use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode;
     use hyperlight_testing::simple_guest_as_string;
 
+    use crate::hypervisor::fpu;
     #[cfg(target_os = "linux")]
     use crate::mem::memory_region::{MemoryRegion, MemoryRegionFlags, MemoryRegionType};
     #[cfg(target_os = "linux")]
@@ -1021,4 +1022,30 @@ mod tests {
         };
         assert_ne!(sandbox3.id, sandbox_id);
     }
+
+    /// Test that FPU control word and MXCSR register are properly reset between guest calls
+    #[test]
+    fn test_fpu_mxcsr_register_reset() {
+        let path = simple_guest_as_string().unwrap();
+        let u_sbox = UninitializedSandbox::new(GuestBinary::FilePath(path), None).unwrap();
+        let mut sandbox = u_sbox.evolve().unwrap();
+
+        // First, read the initial state of FPU and MXCSR registers
+        let initial_state: String = sandbox.call("ReadFpuMxcsr", ()).unwrap();
+        // Verify the initial state matches expected default values
+        let expected = format!("fcw:{:04X},mxcsr:{:08X}", fpu::FP_CONTROL_WORD_DEFAULT, fpu::MXCSR_DEFAULT);
+        assert_eq!(initial_state, expected,
+                  "Initial FPU/MXCSR state does not match expected defaults");
+
+        // Modify the FPU and MXCSR registers to non-default values
+        let modify_result: String = sandbox.call("ModifyFpuMxcsr", ()).unwrap();
+        let expected = format!("fcw:{:04X},mxcsr:{:08X}", 0x027F, 0x1F00);
+        assert_eq!(modify_result, expected,
+                  "Modified state does not match");
+
+        // A new call should reset these
+        let reset_state: String = sandbox.call("ReadFpuMxcsr", ()).unwrap();
+        assert_eq!(initial_state, reset_state,
+                  "FPU/MXCSR registers were not properly reset between calls");
+    }
 }

src/tests/rust_guests/simpleguest/src/main.rs

@@ -930,6 +930,73 @@ fn exec_mapped_buffer(function_call: &FunctionCall) -> Result<Vec<u8>> {
     }
 }
 
+/// Simple function to modify FPU control word and MXCSR register
+#[hyperlight_guest_tracing::trace_function]
+fn modify_fpu_mxcsr(_function_call: &FunctionCall) -> Result<Vec<u8>> {
+    unsafe {
+        // Set FPU control word to a non-default value (default is usually 0x037F)
+        // We'll set it to 0x027F (change precision control and rounding)
+        let new_fcw: u16 = 0x027F;
+        core::arch::asm!(
+            "fldcw [{fcw_ptr}]",
+            fcw_ptr = in(reg) &new_fcw,
+        );
+
+        // Set MXCSR to a non-default value (default is usually 0x1F80)
+        // We'll set it to 0x1F00 (disable some exception masks)
+        let new_mxcsr: u32 = 0x1F00;
+        core::arch::asm!(
+            "ldmxcsr [{mxcsr_ptr}]",
+            mxcsr_ptr = in(reg) &new_mxcsr,
+        );
+    }
+
+    // now read them and return those values
+    let mut fcw: u16 = 0;
+    let mut mxcsr: u32 = 0;
+
+    unsafe {
+        // Read FPU control word
+        core::arch::asm!(
+            "fnstcw [{fcw_ptr}]",
+            fcw_ptr = in(reg) &mut fcw,
+        );
+
+        // Read MXCSR
+        core::arch::asm!(
+            "stmxcsr [{mxcsr_ptr}]",
+            mxcsr_ptr = in(reg) &mut mxcsr,
+        );
+    }
+
+    let result = format!("fcw:{:04X},mxcsr:{:08X}", fcw, mxcsr);
+    Ok(get_flatbuffer_result(result.as_str()))
+}
+
+/// Simple function to read current FPU control word and MXCSR values
+#[hyperlight_guest_tracing::trace_function]
+fn read_fpu_mxcsr(_function_call: &FunctionCall) -> Result<Vec<u8>> {
+    let mut fcw: u16 = 0;
+    let mut mxcsr: u32 = 0;
+
+    unsafe {
+        // Read FPU control word
+        core::arch::asm!(
+            "fnstcw [{fcw_ptr}]",
+            fcw_ptr = in(reg) &mut fcw,
+        );
+
+        // Read MXCSR
+        core::arch::asm!(
+            "stmxcsr [{mxcsr_ptr}]",
+            mxcsr_ptr = in(reg) &mut mxcsr,
+        );
+    }
+
+    let result = format!("fcw:{:04X},mxcsr:{:08X}", fcw, mxcsr);
+    Ok(get_flatbuffer_result(result.as_str()))
+}
+
 #[no_mangle]
 #[hyperlight_guest_tracing::trace_function]
 pub extern "C" fn hyperlight_main() {
@@ -1477,6 +1544,23 @@ pub extern "C" fn hyperlight_main() {
         call_given_paramless_hostfunc_that_returns_i64 as usize,
     );
     register_function(call_given_hostfunc_def);
+
+    // Register FPU and MXCSR test functions
+    let modify_fpu_mxcsr_def = GuestFunctionDefinition::new(
+        "ModifyFpuMxcsr".to_string(),
+        Vec::new(),
+        ReturnType::String,
+        modify_fpu_mxcsr as usize,
+    );
+    register_function(modify_fpu_mxcsr_def);
+
+    let read_fpu_mxcsr_def = GuestFunctionDefinition::new(
+        "ReadFpuMxcsr".to_string(),
+        Vec::new(),
+        ReturnType::String,
+        read_fpu_mxcsr as usize,
+    );
+    register_function(read_fpu_mxcsr_def);
 }
 
 #[hyperlight_guest_tracing::trace_function]