Change interrupt_handle state from AtomicU64 to AtomicU8

Signed-off-by: Ludvig Liljenberg <[email protected]>

Author: ludfjig

docs/cancellation.md

@@ -10,9 +10,9 @@ Hyperlight provides a mechanism to forcefully interrupt guest execution through
 
 ### LinuxInterruptHandle State
 
-The `LinuxInterruptHandle` uses a packed atomic u64 to track execution state:
+The `LinuxInterruptHandle` uses a packed atomic u8 to track execution state:
 
-- **state (AtomicU64)**: Packs three bits:
+- **state (AtomicU8)**: Packs three bits:
   - **Bit 2 (DEBUG_INTERRUPT_BIT)**: Set when debugger interrupt is requested (gdb feature only)
   - **Bit 1 (RUNNING_BIT)**: Set when vCPU is actively running in guest mode
   - **Bit 0 (CANCEL_BIT)**: Set when cancellation has been requested via `kill()`
@@ -255,7 +255,7 @@ While the core cancellation mechanism follows the same conceptual model on Windo
 
 The `WindowsInterruptHandle` uses a simpler structure compared to Linux:
 
-- **state (AtomicU64)**: Packs three bits (RUNNING_BIT, CANCEL_BIT and DEBUG_INTERRUPT_BIT)
+- **state (AtomicU8)**: Packs three bits (RUNNING_BIT, CANCEL_BIT and DEBUG_INTERRUPT_BIT)
 - **partition_handle**: Windows Hyper-V partition handle for the VM
 - **dropped (AtomicBool)**: Set when the corresponding VM has been dropped
 

src/hyperlight_host/src/hypervisor/hyperv_linux.rs

@@ -18,7 +18,7 @@ extern crate mshv_bindings;
 extern crate mshv_ioctls;
 
 use std::fmt::{Debug, Formatter};
-use std::sync::atomic::{AtomicBool, AtomicU64};
+use std::sync::atomic::{AtomicBool, AtomicU8, AtomicU64};
 use std::sync::{Arc, Mutex};
 
 use log::{LevelFilter, error};
@@ -375,7 +375,7 @@ impl HypervLinuxDriver {
         })?;
 
         let interrupt_handle: Arc<dyn InterruptHandleImpl> = Arc::new(LinuxInterruptHandle {
-            state: AtomicU64::new(0),
+            state: AtomicU8::new(0),
             #[cfg(all(
                 target_arch = "x86_64",
                 target_vendor = "unknown",

src/hyperlight_host/src/hypervisor/hyperv_windows.rs

@@ -17,7 +17,7 @@ limitations under the License.
 use std::fmt;
 use std::fmt::{Debug, Formatter};
 use std::string::String;
-use std::sync::atomic::{AtomicBool, AtomicU64};
+use std::sync::atomic::{AtomicBool, AtomicU8};
 use std::sync::{Arc, Mutex};
 
 use log::LevelFilter;
@@ -324,7 +324,7 @@ impl HypervWindowsDriver {
         };
 
         let interrupt_handle = Arc::new(WindowsInterruptHandle {
-            state: AtomicU64::new(0),
+            state: AtomicU8::new(0),
             partition_handle,
             dropped: AtomicBool::new(false),
         });

src/hyperlight_host/src/hypervisor/kvm.rs

@@ -15,7 +15,7 @@ limitations under the License.
 */
 
 use std::fmt::Debug;
-use std::sync::atomic::{AtomicBool, AtomicU64};
+use std::sync::atomic::{AtomicBool, AtomicU8, AtomicU64};
 use std::sync::{Arc, Mutex};
 
 use kvm_bindings::{kvm_fpu, kvm_regs, kvm_sregs, kvm_userspace_memory_region};
@@ -333,7 +333,7 @@ impl KVMDriver {
         let rsp_gp = GuestPtr::try_from(RawPtr::from(rsp))?;
 
         let interrupt_handle: Arc<dyn InterruptHandleImpl> = Arc::new(LinuxInterruptHandle {
-            state: AtomicU64::new(0),
+            state: AtomicU8::new(0),
             #[cfg(all(
                 target_arch = "x86_64",
                 target_vendor = "unknown",

src/hyperlight_host/src/hypervisor/mod.rs

@@ -63,7 +63,9 @@ pub(crate) mod crashdump;
 
 use std::fmt::Debug;
 use std::str::FromStr;
-use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+#[cfg(any(kvm, mshv3))]
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::{AtomicBool, AtomicU8, Ordering};
 use std::sync::{Arc, Mutex};
 #[cfg(any(kvm, mshv3))]
 use std::time::Duration;
@@ -588,7 +590,7 @@ pub(super) struct LinuxInterruptHandle {
     ///
     /// CANCEL_BIT persists across vcpu exits/re-entries within a single `VirtualCPU::run()` call
     /// (e.g., during host function calls), but is cleared at the start of each new `VirtualCPU::run()` call.
-    state: AtomicU64,
+    state: AtomicU8,
 
     /// Thread ID where the vcpu is running.
     ///
@@ -608,10 +610,10 @@ pub(super) struct LinuxInterruptHandle {
 
 #[cfg(any(kvm, mshv3))]
 impl LinuxInterruptHandle {
-    const RUNNING_BIT: u64 = 1 << 1;
-    const CANCEL_BIT: u64 = 1 << 0;
+    const RUNNING_BIT: u8 = 1 << 1;
+    const CANCEL_BIT: u8 = 1 << 0;
     #[cfg(gdb)]
-    const DEBUG_INTERRUPT_BIT: u64 = 1 << 2;
+    const DEBUG_INTERRUPT_BIT: u8 = 1 << 2;
 
     /// Get the running, cancel and debug flags atomically.
     ///
@@ -756,18 +758,18 @@ pub(super) struct WindowsInterruptHandle {
     ///
     /// CANCEL_BIT persists across vcpu exits/re-entries within a single `VirtualCPU::run()` call
     /// (e.g., during host function calls), but is cleared at the start of each new `VirtualCPU::run()` call.
-    state: AtomicU64,
+    state: AtomicU8,
 
     partition_handle: windows::Win32::System::Hypervisor::WHV_PARTITION_HANDLE,
     dropped: AtomicBool,
 }
 
 #[cfg(target_os = "windows")]
 impl WindowsInterruptHandle {
-    const RUNNING_BIT: u64 = 1 << 1;
-    const CANCEL_BIT: u64 = 1 << 0;
+    const RUNNING_BIT: u8 = 1 << 1;
+    const CANCEL_BIT: u8 = 1 << 0;
     #[cfg(gdb)]
-    const DEBUG_INTERRUPT_BIT: u64 = 1 << 2;
+    const DEBUG_INTERRUPT_BIT: u8 = 1 << 2;
 }
 
 #[cfg(target_os = "windows")]