feat(opentmk): opentmk framework with first testcase

opentmk/src/arch/x86_64/interrupt_handler_register.rs

@@ -9,7 +9,7 @@ use x86_64::structures::idt::PageFaultErrorCode;
 static mut COMMON_HANDLER: fn(InterruptStackFrame, u8) = common_handler;
 static COMMON_HANDLER_MUTEX: Mutex<()> = Mutex::new(());
 
-#[unsafe(no_mangle)]
+#[no_mangle]
 fn abstraction_handle(stack_frame: InterruptStackFrame, interrupt: u8) {
     // SAFETY: COMMON_HANDLER is only set via set_common_handler which is protected by a mutex.
     unsafe { (COMMON_HANDLER)(stack_frame, interrupt) };

opentmk/src/platform/hyperv/arch/aarch64/hypercall.rs

@@ -29,10 +29,7 @@ impl HvCall {
             .expect("size of start_virtual_processor header is not correct");
 
         let output = self.dispatch_hvcall(hvdef::HypercallCode::HvCallStartVirtualProcessor, None);
-        match output.result() {
-            Ok(()) => Ok(()),
-            err => panic!("Failed to start virtual processor: {:?}", err),
-        }
+        output.result()
     }
 
     /// Enables a VTL for a specific virtual processor (VP) on aarch64.
@@ -55,10 +52,7 @@ impl HvCall {
         _ = header.write_to_prefix(self.input_page().buffer.as_mut_slice());
 
         let output = self.dispatch_hvcall(hvdef::HypercallCode::HvCallEnableVpVtl, None);
-        match output.result() {
-            Ok(()) | Err(hvdef::HvError::VtlAlreadyEnabled) => Ok(()),
-            err => err,
-        }
+        output.result()
     }
 
     /// Placeholder for VTL call on aarch64.

opentmk/src/platform/hyperv/arch/x86_64/hypercall.rs

@@ -54,10 +54,7 @@ impl HvCall {
             .expect("size of start_virtual_processor header is not correct");
 
         let output = self.dispatch_hvcall(hvdef::HypercallCode::HvCallStartVirtualProcessor, None);
-        match output.result() {
-            Ok(()) => Ok(()),
-            err => panic!("Failed to start virtual processor: {:?}", err),
-        }
+        output.result()
     }
 
     /// Enables a VTL for a specific virtual processor (VP) on x86_64.
@@ -80,10 +77,7 @@ impl HvCall {
             .expect("size of enable_vp_vtl header is not correct");
 
         let output = self.dispatch_hvcall(hvdef::HypercallCode::HvCallEnableVpVtl, None);
-        match output.result() {
-            Ok(()) | Err(hvdef::HvError::VtlAlreadyEnabled) => Ok(()),
-            err => err,
-        }
+        output.result()
     }
 
     /// Retrieves the current VTL context by reading the necessary registers.

opentmk/src/tests/hyperv/hv_register_intercept.rs

@@ -79,7 +79,7 @@ where
         tmk_assert!(r.is_ok(), "get_register should succeed to read Control register");
 
         let reg_values = r.unwrap();
-        tmk_assert!(reg_values == 0x0000000000001000, format!("register value should be 0x0000000000000800, got {:x}", reg_values));
+        tmk_assert!(reg_values == 0x0000000000001000, format!("register value should be 0x0000000000001000, got {:x}", reg_values));
 
         log::info!("Switching to VTL0: attempting to read a protected register to verify security enforcement and intercept handling.");
 

opentmk/src/tests/hyperv/test_helpers.rs

@@ -2,13 +2,13 @@
 // Licensed under the MIT License.
 
 #[macro_export]
-/// Generates a function that calls the given symbol saving and restoring all registers around the call.
+/// Generates a function that calls the given symbol saving and restoring general purpose registers around the call.
 macro_rules! create_function_with_restore {
     ($func_name:ident, $symbol:ident) => {
         #[inline(never)]
         // avoiding inline for debuggability in release builds.
         fn $func_name() {
-            // SAFETY: we are calling a function pointer and restoring all registers.
+            // SAFETY: we are calling a function pointer and restoring general purpose registers.
             unsafe {
                 asm!("
                     push rax

support/nostd_spin_channel/src/lib.rs

@@ -186,20 +186,30 @@ impl<T> Receiver<T> {
     /// Tries to receive an element from the front of the queue while blocking
     /// Returns Ok(value) if successful, Err(RecvError) otherwise
     pub fn recv(&self) -> Result<T, RecvError> {
-        // Use a separate scope for the lock to ensure it's released promptly
-        let result = {
-            let mut buffer = self.inner.buffer.lock();
-            buffer.pop_front()
-        };
-        match result {
-            Some(val) => Ok(val),
-            None => {
-                // Check if there are any senders left
-                if self.inner.senders.load(Ordering::SeqCst) == 0 {
-                    Err(RecvError::Disconnected)
-                } else {
-                    Err(RecvError::Empty)
+        loop {
+            // Use a separate scope for the lock to ensure it's released promptly
+            let result = {
+                let mut buffer = self.inner.buffer.lock();
+                buffer.pop_front()
+            };
+            let r = match result {
+                Some(val) => Ok(val),
+                None => {
+                    // Check if there are any senders left
+                    if self.inner.senders.load(Ordering::SeqCst) == 0 {
+                        Err(RecvError::Disconnected)
+                    } else {
+                        Err(RecvError::Empty)
+                    }
                 }
+            };
+
+            if let Err(err) = r {
+                if err != RecvError::Empty {
+                    return Err(err);
+                }
+            } else {
+                return r;
             }
         }
     }