Reorder to minimize diff

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

Author: ludfjig

src/hyperlight_host/src/hypervisor/hyperv_linux.rs

@@ -90,41 +90,6 @@ impl MshvVm {
 }
 
 impl Hypervisor for MshvVm {
-    fn regs(&self) -> Result<CommonRegisters> {
-        Ok((&self.vcpu_fd.get_regs()?).into())
-    }
-
-    fn set_regs(&self, regs: &CommonRegisters) -> Result<()> {
-        Ok(self.vcpu_fd.set_regs(&regs.into())?)
-    }
-
-    fn sregs(&self) -> Result<CommonSpecialRegisters> {
-        Ok((&self.vcpu_fd.get_sregs()?).into())
-    }
-
-    fn set_sregs(&self, sregs: &CommonSpecialRegisters) -> Result<()> {
-        self.vcpu_fd.set_sregs(&sregs.into())?;
-        Ok(())
-    }
-
-    fn fpu(&self) -> Result<CommonFpu> {
-        Ok((&self.vcpu_fd.get_fpu()?).into())
-    }
-
-    fn set_fpu(&self, fpu: &CommonFpu) -> Result<()> {
-        self.vcpu_fd.set_fpu(&fpu.into())?;
-        Ok(())
-    }
-
-    #[cfg(crashdump)]
-    fn xsave(&self) -> Result<Vec<u8>> {
-        let xsave = self.vcpu_fd.get_xsave()?;
-        Ok(xsave.buffer.to_vec())
-    }
-
-    /// # Safety
-    /// The caller must ensure that the memory region is valid and points to valid memory,
-    /// and lives long enough for the VM to use it.
     unsafe fn map_memory(&mut self, (_slot, region): (u32, &MemoryRegion)) -> Result<()> {
         let mshv_region: mshv_user_mem_region = region.into();
         self.vm_fd.map_user_memory(mshv_region)?;
@@ -209,6 +174,38 @@ impl Hypervisor for MshvVm {
         };
         Ok(result)
     }
+
+    fn regs(&self) -> Result<CommonRegisters> {
+        Ok((&self.vcpu_fd.get_regs()?).into())
+    }
+
+    fn set_regs(&self, regs: &CommonRegisters) -> Result<()> {
+        Ok(self.vcpu_fd.set_regs(&regs.into())?)
+    }
+
+    fn fpu(&self) -> Result<CommonFpu> {
+        Ok((&self.vcpu_fd.get_fpu()?).into())
+    }
+
+    fn set_fpu(&self, fpu: &CommonFpu) -> Result<()> {
+        self.vcpu_fd.set_fpu(&fpu.into())?;
+        Ok(())
+    }
+
+    fn sregs(&self) -> Result<CommonSpecialRegisters> {
+        Ok((&self.vcpu_fd.get_sregs()?).into())
+    }
+
+    fn set_sregs(&self, sregs: &CommonSpecialRegisters) -> Result<()> {
+        self.vcpu_fd.set_sregs(&sregs.into())?;
+        Ok(())
+    }
+
+    #[cfg(crashdump)]
+    fn xsave(&self) -> Result<Vec<u8>> {
+        let xsave = self.vcpu_fd.get_xsave()?;
+        Ok(xsave.buffer.to_vec())
+    }
 }
 
 #[cfg(gdb)]
@@ -229,37 +226,36 @@ impl DebuggableVm for MshvVm {
 
     fn set_debug(&mut self, enabled: bool) -> Result<()> {
         use mshv_bindings::{
-            HV_INTERCEPT_ACCESS_MASK_EXECUTE, hv_intercept_parameters,
-            hv_intercept_type_HV_INTERCEPT_TYPE_EXCEPTION, mshv_install_intercept,
+            HV_INTERCEPT_ACCESS_MASK_EXECUTE, HV_INTERCEPT_ACCESS_MASK_NONE,
+            hv_intercept_parameters, hv_intercept_type_HV_INTERCEPT_TYPE_EXCEPTION,
+            mshv_install_intercept,
         };
 
         use crate::hypervisor::gdb::arch::{BP_EX_ID, DB_EX_ID};
 
-        if enabled {
-            self.vm_fd
-                .install_intercept(mshv_install_intercept {
-                    access_type_mask: HV_INTERCEPT_ACCESS_MASK_EXECUTE,
-                    intercept_type: hv_intercept_type_HV_INTERCEPT_TYPE_EXCEPTION,
-                    // Exception handler #DB (1)
-                    intercept_parameter: hv_intercept_parameters {
-                        exception_vector: DB_EX_ID as u16,
-                    },
-                })
-                .map_err(|e| new_error!("Cannot install debug exception intercept: {}", e))?;
+        let access_type_mask = if enabled {
+            HV_INTERCEPT_ACCESS_MASK_EXECUTE
+        } else {
+            HV_INTERCEPT_ACCESS_MASK_NONE
+        };
 
-            // Install intercept for #BP (3) exception
+        for vector in [DB_EX_ID, BP_EX_ID] {
             self.vm_fd
                 .install_intercept(mshv_install_intercept {
-                    access_type_mask: HV_INTERCEPT_ACCESS_MASK_EXECUTE,
+                    access_type_mask,
                     intercept_type: hv_intercept_type_HV_INTERCEPT_TYPE_EXCEPTION,
-                    // Exception handler #BP (3)
                     intercept_parameter: hv_intercept_parameters {
-                        exception_vector: BP_EX_ID as u16,
+                        exception_vector: vector as u16,
                     },
                 })
-                .map_err(|e| new_error!("Cannot install breakpoint exception intercept: {}", e))?;
-        } else {
-            // There doesn't seem to be any way to remove installed intercepts. But that's okay.
+                .map_err(|e| {
+                    new_error!(
+                        "Cannot {} exception intercept for vector {}: {}",
+                        if enabled { "install" } else { "remove" },
+                        vector,
+                        e
+                    )
+                })?;
         }
         Ok(())
     }