fixup! [common/input_output] making input_output stacks portable

Author: danbugs

src/hyperlight_common/src/host_calling.rs

@@ -1,14 +1,15 @@
-use crate::flatbuffer_wrappers::function_types::{ParameterValue, ReturnType, ReturnValue};
-use crate::input_output::{InputDataSection, OutputDataSection};
+use alloc::string::ToString;
+use alloc::vec::Vec;
+use core::ffi::c_char;
+
 use anyhow::Result;
+
 use crate::flatbuffer_wrappers::function_call::{FunctionCall, FunctionCallType};
+use crate::flatbuffer_wrappers::function_types::{ParameterValue, ReturnType, ReturnValue};
+use crate::input_output::{InputDataSection, OutputDataSection};
 use crate::outb::{outb, OutBAction};
 use crate::PEB;
 
-use alloc::vec::Vec;
-use alloc::string::ToString;
-use core::ffi::c_char;
-
 /// Get a return value from a host function call.
 /// This usually requires a host function to be called first using `call_host_function`.
 pub fn get_host_return_value<T: TryFrom<ReturnValue>>() -> Result<T> {
@@ -19,7 +20,10 @@ pub fn get_host_return_value<T: TryFrom<ReturnValue>>() -> Result<T> {
         .expect("Unable to deserialize a return value from host");
 
     T::try_from(return_value).map_err(|_| {
-        anyhow::anyhow!("Host return value was not a {} as expected", core::any::type_name::<T>())
+        anyhow::anyhow!(
+            "Host return value was not a {} as expected",
+            core::any::type_name::<T>()
+        )
     })
 }
 
@@ -44,8 +48,7 @@ pub fn call_host_function(
 
     let output_data_section: OutputDataSection =
         unsafe { (*PEB).clone() }.get_output_data_region().into();
-    output_data_section
-        .push_shared_output_data(host_function_call_buffer)?;
+    output_data_section.push_shared_output_data(host_function_call_buffer)?;
 
     outb(OutBAction::CallFunction as u16, 0);
 
@@ -66,4 +69,4 @@ pub fn print(message: &str) {
 #[no_mangle]
 pub unsafe extern "C" fn _putchar(c: c_char) {
     outb(OutBAction::DebugPrint as u16, c as u8);
-}
+}

src/hyperlight_common/src/input_output.rs

@@ -13,10 +13,11 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
-use anyhow::{bail, Result};
 use alloc::vec::Vec;
 use core::slice::from_raw_parts_mut;
 
+use anyhow::{bail, Result};
+
 pub struct InputDataSection {
     ptr: *mut u8,
     len: u64,
@@ -33,9 +34,7 @@ impl InputDataSection {
     {
         let shared_buffer_size = self.len as usize;
 
-        let idb = unsafe {
-            from_raw_parts_mut(self.ptr, shared_buffer_size)
-        };
+        let idb = unsafe { from_raw_parts_mut(self.ptr, shared_buffer_size) };
 
         if idb.is_empty() {
             bail!("Got a 0-size buffer in try_pop_shared_input_data_into");
@@ -48,14 +47,17 @@ impl InputDataSection {
         });
 
         if stack_ptr_rel as usize > shared_buffer_size || stack_ptr_rel < 16 {
-            bail!("Invalid stack pointer: {} in try_pop_shared_input_data_into", stack_ptr_rel);
+            bail!(
+                "Invalid stack pointer: {} in try_pop_shared_input_data_into",
+                stack_ptr_rel
+            );
         }
 
         // go back 8 bytes and read. This is the offset to the element on top of stack
         let last_element_offset_rel = u64::from_le_bytes(
             match idb[stack_ptr_rel as usize - 8..stack_ptr_rel as usize].try_into() {
                 Ok(bytes) => bytes,
-                Err(_) => bail!("Invalid stack pointer in pop_shared_input_data_into")
+                Err(_) => bail!("Invalid stack pointer in pop_shared_input_data_into"),
             },
         );
 
@@ -91,18 +93,18 @@ impl OutputDataSection {
 
     pub fn push_shared_output_data(&self, data: Vec<u8>) -> Result<()> {
         let shared_buffer_size = self.len as usize;
-        let odb: &mut [u8] =
-            unsafe { from_raw_parts_mut(self.ptr, shared_buffer_size) };
+        let odb: &mut [u8] = unsafe { from_raw_parts_mut(self.ptr, shared_buffer_size) };
 
         if odb.len() < Self::STACK_PTR_SIZE {
             bail!("shared output buffer is too small");
         }
 
         // get offset to next free address on the stack
-        let mut stack_ptr_rel: u64 = u64::from_le_bytes(match odb[..Self::STACK_PTR_SIZE].try_into() {
-            Ok(bytes) => bytes,
-            Err(_) => bail!("failed to get stack pointer in shared output buffer"),
-        });
+        let mut stack_ptr_rel: u64 =
+            u64::from_le_bytes(match odb[..Self::STACK_PTR_SIZE].try_into() {
+                Ok(bytes) => bytes,
+                Err(_) => bail!("failed to get stack pointer in shared output buffer"),
+            });
 
         // if stack_ptr_rel is 0, it means this is the first time we're using the output buffer, so
         // we want to offset it by 8 as to not overwrite the stack_ptr location.
@@ -152,4 +154,4 @@ impl From<(u64, u64)> for OutputDataSection {
     fn from((ptr, len): (u64, u64)) -> Self {
         OutputDataSection::new(ptr as *mut u8, len)
     }
-}
+}

src/hyperlight_common/src/outb.rs

@@ -1,5 +1,7 @@
 use core::arch;
+
 use anyhow::{bail, Result};
+
 use crate::hyperlight_peb::RunMode;
 use crate::RUNNING_MODE;
 
@@ -30,7 +32,9 @@ impl TryFrom<u16> for OutBAction {
 
 /// Issues an OUTB instruction to the specified port with the given value.
 fn hloutb(port: u16, val: u8) {
-    unsafe { arch::asm!("out dx, al", in("dx") port, in("al") val, options(preserves_flags, nomem, nostack)); }
+    unsafe {
+        arch::asm!("out dx, al", in("dx") port, in("al") val, options(preserves_flags, nomem, nostack));
+    }
 }
 
 pub fn outb(port: u16, value: u8) {

src/hyperlight_guest/src/entrypoint.rs

@@ -18,10 +18,11 @@ use core::ffi::{c_char, CStr};
 use core::ptr::copy_nonoverlapping;
 
 use hyperlight_common::hyperlight_peb::{HyperlightPEB, RunMode};
-use log::LevelFilter;
-use spin::Once;
 use hyperlight_common::outb::{outb, OutBAction};
 use hyperlight_common::{PEB, RUNNING_MODE};
+use log::LevelFilter;
+use spin::Once;
+
 use crate::gdt::load_gdt;
 use crate::guest_error::reset_error;
 use crate::guest_function_call::dispatch_function;

src/hyperlight_guest/src/guest_error.rs

@@ -19,9 +19,10 @@ use alloc::vec::Vec;
 use core::ffi::{c_char, CStr};
 
 use hyperlight_common::flatbuffer_wrappers::guest_error::{ErrorCode, GuestError};
-use log::error;
 use hyperlight_common::outb::{outb, OutBAction};
 use hyperlight_common::PEB;
+use log::error;
+
 use crate::entrypoint::halt;
 
 pub(crate) fn write_error(error_code: ErrorCode, message: Option<&str>) {

src/hyperlight_guest/src/lib.rs

@@ -96,4 +96,3 @@ pub static mut MIN_STACK_ADDRESS: u64 = 0;
 
 pub(crate) static mut REGISTERED_GUEST_FUNCTIONS: GuestFunctionRegister =
     GuestFunctionRegister::new();
-

src/hyperlight_host/src/sandbox/outb.rs

@@ -19,10 +19,11 @@ use std::sync::{Arc, Mutex};
 use hyperlight_common::flatbuffer_wrappers::function_types::ParameterValue;
 use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode;
 use hyperlight_common::flatbuffer_wrappers::guest_log_data::GuestLogData;
+use hyperlight_common::outb::OutBAction;
 use log::{Level, Record};
 use tracing::{instrument, Span};
 use tracing_log::format_trace;
-use hyperlight_common::outb::OutBAction;
+
 use super::host_funcs::HostFuncsWrapper;
 use crate::hypervisor::handlers::{OutBHandler, OutBHandlerFunction, OutBHandlerWrapper};
 use crate::mem::mgr::SandboxMemoryManager;

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

@@ -40,6 +40,7 @@ use hyperlight_common::flatbuffer_wrappers::function_types::{
 use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode;
 use hyperlight_common::flatbuffer_wrappers::guest_log_level::LogLevel;
 use hyperlight_common::flatbuffer_wrappers::util::get_flatbuffer_result;
+use hyperlight_common::host_calling::{call_host_function, get_host_return_value, print};
 use hyperlight_common::PAGE_SIZE;
 use hyperlight_guest::entrypoint::{abort_with_code, abort_with_code_and_message};
 use hyperlight_guest::error::{HyperlightGuestError, Result};
@@ -48,7 +49,6 @@ use hyperlight_guest::guest_function_register::register_function;
 use hyperlight_guest::memory::malloc;
 use hyperlight_guest::{logging, MIN_STACK_ADDRESS};
 use log::{error, LevelFilter};
-use hyperlight_common::host_calling::{call_host_function, get_host_return_value, print};
 
 extern crate hyperlight_guest;