[common/outb,guest/*,host/{drivers,outb}] added DebugPrint OutBAction

- added action to enable eprinting from an out instruction.
- changed out instruciton to output 4 bytes for optimized printing.

Signed-off-by: danbugs <[email protected]>

Author: danbugs

src/hyperlight_common/src/outb.rs

@@ -1,7 +1,13 @@
+/// Supported actions when issuing an OUTB actions by Hyperlight.
+/// - Log: for logging,
+/// - CallFunction: makes a call to a host function,
+/// - Abort: aborts the execution of the guest,
+/// - DebugPrint: prints a message to the host
 pub enum OutBAction {
     Log = 99,
     CallFunction = 101,
     Abort = 102,
+    DebugPrint = 103,
 }
 
 impl TryFrom<u16> for OutBAction {
@@ -11,6 +17,7 @@ impl TryFrom<u16> for OutBAction {
             99 => Ok(OutBAction::Log),
             101 => Ok(OutBAction::CallFunction),
             102 => Ok(OutBAction::Abort),
+            103 => Ok(OutBAction::DebugPrint),
             _ => Err(anyhow::anyhow!("Invalid OutBAction value: {}", val)),
         }
     }

src/hyperlight_guest/src/entrypoint.rs

@@ -48,7 +48,8 @@ pub extern "C" fn abort() -> ! {
 }
 
 pub fn abort_with_code(code: i32) -> ! {
-    outb(OutBAction::Abort as u16, code as u8);
+    let byte = code as u8;
+    outb(OutBAction::Abort as u16, &[byte]);
     unreachable!()
 }
 
@@ -63,7 +64,8 @@ pub unsafe fn abort_with_code_and_message(code: i32, message_ptr: *const c_char)
         (*peb_ptr).guestPanicContextData.guestPanicContextDataBuffer as *mut c_char,
         CStr::from_ptr(message_ptr).count_bytes() + 1, // +1 for null terminator
     );
-    outb(OutBAction::Abort as u16, code as u8);
+    let byte = code as u8;
+    outb(OutBAction::Abort as u16, &[byte]);
     unreachable!()
 }
 
@@ -115,7 +117,7 @@ pub extern "win64" fn entrypoint(peb_address: u64, seed: u64, ops: u64, max_log_
                     RUNNING_MODE = (*peb_ptr).runMode;
 
                     OUTB_PTR = {
-                        let outb_ptr: extern "win64" fn(u16, u8) =
+                        let outb_ptr: extern "win64" fn(u16, *const u8, u64) =
                             core::mem::transmute((*peb_ptr).pOutb);
                         Some(outb_ptr)
                     };
@@ -125,8 +127,12 @@ pub extern "win64" fn entrypoint(peb_address: u64, seed: u64, ops: u64, max_log_
                     }
 
                     OUTB_PTR_WITH_CONTEXT = {
-                        let outb_ptr_with_context: extern "win64" fn(*mut c_void, u16, u8) =
-                            core::mem::transmute((*peb_ptr).pOutb);
+                        let outb_ptr_with_context: extern "win64" fn(
+                            *mut c_void,
+                            u16,
+                            *const u8,
+                            u64,
+                        ) = core::mem::transmute((*peb_ptr).pOutb);
                         Some(outb_ptr_with_context)
                     };
                 }

src/hyperlight_guest/src/guest_error.rs

@@ -49,7 +49,7 @@ pub(crate) fn set_error_and_halt(error_code: ErrorCode, message: &str) {
 
 #[no_mangle]
 pub(crate) extern "win64" fn set_stack_allocate_error() {
-    outb(OutBAction::Abort as u16, ErrorCode::StackOverflow as u8);
+    outb(OutBAction::Abort as u16, &[ErrorCode::StackOverflow as u8]);
 }
 
 #[no_mangle]

src/hyperlight_guest/src/host_function_call.rs

@@ -70,24 +70,40 @@ pub fn call_host_function(
 
     push_shared_output_data(host_function_call_buffer)?;
 
-    outb(OutBAction::CallFunction as u16, 0);
+    outb(OutBAction::CallFunction as u16, &[0]);
 
     Ok(())
 }
 
-pub fn outb(port: u16, value: u8) {
+pub fn outb(port: u16, data: &[u8]) {
     unsafe {
         match RUNNING_MODE {
             RunMode::Hypervisor => {
-                hloutb(port, value);
+                for chunk in data.chunks(4) {
+                    let val = match chunk {
+                        [a, b, c, d] => u32::from_le_bytes([*a, *b, *c, *d]),
+                        [a, b, c] => u32::from_le_bytes([*a, *b, *c, 0]),
+                        [a, b] => u32::from_le_bytes([*a, *b, 0, 0]),
+                        [a] => u32::from_le_bytes([*a, 0, 0, 0]),
+                        [] => break,
+                        _ => unreachable!(),
+                    };
+
+                    hloutd(val, port);
+                }
             }
             RunMode::InProcessLinux | RunMode::InProcessWindows => {
                 if let Some(outb_func) = OUTB_PTR_WITH_CONTEXT {
                     if let Some(peb_ptr) = P_PEB {
-                        outb_func((*peb_ptr).pOutbContext, port, value);
+                        outb_func(
+                            (*peb_ptr).pOutbContext,
+                            port,
+                            data.as_ptr(),
+                            data.len() as u64,
+                        );
                     }
                 } else if let Some(outb_func) = OUTB_PTR {
-                    outb_func(port, value);
+                    outb_func(port, data.as_ptr(), data.len() as u64);
                 } else {
                     panic!("Tried to call outb without hypervisor and without outb function ptrs");
                 }
@@ -100,7 +116,7 @@ pub fn outb(port: u16, value: u8) {
 }
 
 extern "win64" {
-    fn hloutb(port: u16, value: u8);
+    fn hloutd(value: u32, port: u16);
 }
 
 pub fn print_output_as_guest_function(function_call: &FunctionCall) -> Result<Vec<u8>> {
@@ -120,13 +136,15 @@ pub fn print_output_as_guest_function(function_call: &FunctionCall) -> Result<Ve
     }
 }
 
-// port: RCX(cx), value: RDX(dl)
+pub fn debug_print(msg: &str) {
+    outb(OutBAction::DebugPrint as u16, msg.as_bytes());
+}
+
 global_asm!(
-    ".global hloutb
-        hloutb:
-            xor rax, rax
-            mov al, dl
-            mov dx, cx
-            out dx, al
-            ret"
+    ".global hloutd
+     hloutd:
+        mov eax, ecx
+        mov dx, dx
+        out dx, eax
+        ret"
 );

src/hyperlight_guest/src/lib.rs

@@ -81,7 +81,7 @@ fn panic(info: &core::panic::PanicInfo) -> ! {
             (*peb_ptr).guestPanicContextData.guestPanicContextDataSize as usize,
         );
     }
-    outb(OutBAction::Abort as u16, ErrorCode::UnknownError as u8);
+    outb(OutBAction::Abort as u16, &[ErrorCode::UnknownError as u8]);
     unsafe { unreachable_unchecked() }
 }
 
@@ -97,9 +97,9 @@ pub(crate) static mut P_PEB: Option<*mut HyperlightPEB> = None;
 pub static mut MIN_STACK_ADDRESS: u64 = 0;
 
 pub static mut OS_PAGE_SIZE: u32 = 0;
-pub(crate) static mut OUTB_PTR: Option<extern "win64" fn(u16, u8)> = None;
+pub(crate) static mut OUTB_PTR: Option<extern "win64" fn(u16, *const u8, u64)> = None;
 pub(crate) static mut OUTB_PTR_WITH_CONTEXT: Option<
-    extern "win64" fn(*mut core::ffi::c_void, u16, u8),
+    extern "win64" fn(*mut core::ffi::c_void, u16, *const u8, u64),
 > = None;
 pub static mut RUNNING_MODE: RunMode = RunMode::None;
 

src/hyperlight_guest/src/logging.rs

@@ -57,5 +57,5 @@ pub fn log_message(
     line: u32,
 ) {
     write_log_data(log_level, message, source, caller, source_file, line);
-    outb(OutBAction::Log as u16, 0);
+    outb(OutBAction::Log as u16, &[0]);
 }

src/hyperlight_host/src/hypervisor/handlers.rs

@@ -25,7 +25,7 @@ use crate::{new_error, Result};
 /// has initiated an outb operation.
 pub trait OutBHandlerCaller: Sync + Send {
     /// Function that gets called when an outb operation has occurred.
-    fn call(&mut self, port: u16, payload: u64) -> Result<()>;
+    fn call(&mut self, port: u16, payload: Vec<u8>) -> Result<()>;
 }
 
 /// A convenient type representing a common way `OutBHandler` implementations
@@ -36,7 +36,7 @@ pub trait OutBHandlerCaller: Sync + Send {
 /// a &mut self).
 pub type OutBHandlerWrapper = Arc<Mutex<dyn OutBHandlerCaller>>;
 
-pub(crate) type OutBHandlerFunction = Box<dyn FnMut(u16, u64) -> Result<()> + Send>;
+pub(crate) type OutBHandlerFunction = Box<dyn FnMut(u16, Vec<u8>) -> Result<()> + Send>;
 
 /// A `OutBHandler` implementation using a `OutBHandlerFunction`
 ///
@@ -52,7 +52,7 @@ impl From<OutBHandlerFunction> for OutBHandler {
 
 impl OutBHandlerCaller for OutBHandler {
     #[instrument(err(Debug), skip_all, parent = Span::current(), level= "Trace")]
-    fn call(&mut self, port: u16, payload: u64) -> Result<()> {
+    fn call(&mut self, port: u16, payload: Vec<u8>) -> Result<()> {
         let mut func = self
             .0
             .try_lock()

src/hyperlight_host/src/hypervisor/hyperv_linux.rs

@@ -542,11 +542,10 @@ impl Hypervisor for HypervLinuxDriver {
         instruction_length: u64,
         outb_handle_fn: OutBHandlerWrapper,
     ) -> Result<()> {
-        let payload = data[..8].try_into()?;
         outb_handle_fn
             .try_lock()
             .map_err(|e| new_error!("Error locking at {}:{}: {}", file!(), line!(), e))?
-            .call(port, u64::from_le_bytes(payload))?;
+            .call(port, data)?;
 
         // update rip
         self.vcpu_fd.set_reg(&[hv_register_assoc {

src/hyperlight_host/src/hypervisor/hyperv_windows.rs

@@ -390,11 +390,10 @@ impl Hypervisor for HypervWindowsDriver {
         instruction_length: u64,
         outb_handle_fn: OutBHandlerWrapper,
     ) -> Result<()> {
-        let payload = data[..8].try_into()?;
         outb_handle_fn
             .try_lock()
             .map_err(|e| new_error!("Error locking at {}:{}: {}", file!(), line!(), e))?
-            .call(port, u64::from_le_bytes(payload))?;
+            .call(port, payload)?;
 
         let mut regs = self.processor.get_regs()?;
         regs.rip = rip + instruction_length;

src/hyperlight_host/src/hypervisor/kvm.rs

@@ -497,11 +497,10 @@ impl Hypervisor for KVMDriver {
         if data.is_empty() {
             log_then_return!("no data was given in IO interrupt");
         } else {
-            let payload_u64 = u64::from(data[0]);
             outb_handle_fn
                 .try_lock()
                 .map_err(|e| new_error!("Error locking at {}:{}: {}", file!(), line!(), e))?
-                .call(port, payload_u64)?;
+                .call(port, data)?;
         }
 
         Ok(())
@@ -665,7 +664,7 @@ mod tests {
         }
 
         let outb_handler: Arc<Mutex<OutBHandler>> = {
-            let func: Box<dyn FnMut(u16, u64) -> Result<()> + Send> =
+            let func: Box<dyn FnMut(u16, Vec<u8>) -> Result<()> + Send> =
                 Box::new(|_, _| -> Result<()> { Ok(()) });
             Arc::new(Mutex::new(OutBHandler::from(func)))
         };

src/hyperlight_host/src/sandbox/leaked_outb.rs

@@ -29,13 +29,19 @@ use crate::mem::shared_mem::GuestSharedMemory;
 ///
 /// NOTE: This is not part of the C Hyperlight API , it is intended only to be
 /// called in proc through a pointer passed to the guest.
-extern "win64" fn call_outb(ptr: *mut Arc<Mutex<dyn OutBHandlerCaller>>, port: u16, data: u64) {
+extern "win64" fn call_outb(
+    ptr: *mut Arc<Mutex<dyn OutBHandlerCaller>>,
+    port: u16,
+    data_ptr: *const u8,
+    data_len: u64,
+) {
     let outb_handlercaller = unsafe { Box::from_raw(ptr) };
+    let slice = unsafe { std::slice::from_raw_parts(data_ptr, data_len as usize) };
     let res = outb_handlercaller
         .try_lock()
         .map_err(|_| crate::new_error!("Error locking"))
         .unwrap()
-        .call(port, data);
+        .call(port, slice.to_vec());
     // TODO, handle the case correctly when res is an error
     assert!(
         res.is_ok(),

src/hyperlight_host/src/sandbox/outb.rs

@@ -99,7 +99,7 @@ fn handle_outb_impl(
     mem_mgr: &mut MemMgrWrapper<HostSharedMemory>,
     host_funcs: Arc<Mutex<HostFuncsWrapper>>,
     port: u16,
-    byte: u64,
+    data: Vec<u8>,
 ) -> Result<()> {
     match port.try_into()? {
         OutBAction::Log => outb_log(mem_mgr.as_mut()),
@@ -118,6 +118,7 @@ fn handle_outb_impl(
             Ok(())
         }
         OutBAction::Abort => {
+            let byte = u64::from(data[0]);
             let guest_error = ErrorCode::from(byte);
             let panic_context = mem_mgr.as_mut().read_guest_panic_context_data()?;
             // trim off trailing \0 bytes if they exist
@@ -135,6 +136,11 @@ fn handle_outb_impl(
                 )),
             }
         }
+        OutBAction::DebugPrint => {
+            let s = String::from_utf8_lossy(&data);
+            eprint!("{}", s);
+            Ok(())
+        }
     }
 }