[common/peb,guest/host_{error, function_call},host/{mem,func}] removed host error region

This region was unused. Ever since we ported our code from C# to Rust, if there's an error calling a host function,
the host will just error out instead of returning to the guest, which is probably more sensible.

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

Author: danbugs

src/hyperlight_common/src/mem/mod.rs

@@ -28,11 +28,6 @@ pub struct HostFunctionDefinitions {
     pub fbHostFunctionDetails: *mut c_void,
 }
 
-#[repr(C)]
-pub struct HostException {
-    pub hostExceptionSize: u64,
-}
-
 #[repr(C)]
 pub struct GuestErrorData {
     pub guestErrorSize: u64,
@@ -89,7 +84,6 @@ pub struct GuestPanicContextData {
 pub struct HyperlightPEB {
     pub security_cookie_seed: u64,
     pub guest_function_dispatch_ptr: u64,
-    pub hostException: HostException,
     pub guestErrorData: GuestErrorData,
     pub pCode: *mut c_char,
     pub pOutb: *mut c_void,

src/hyperlight_guest/src/host_error.rs

@@ -28,7 +28,6 @@ use hyperlight_common::flatbuffer_wrappers::util::get_flatbuffer_result;
 use hyperlight_common::mem::RunMode;
 
 use crate::error::{HyperlightGuestError, Result};
-use crate::host_error::check_for_host_error;
 use crate::shared_input_data::try_pop_shared_input_data_into;
 use crate::shared_output_data::push_shared_output_data;
 use crate::{OUTB_PTR, OUTB_PTR_WITH_CONTEXT, P_PEB, RUNNING_MODE};
@@ -102,8 +101,6 @@ pub fn outb(port: u16, value: u8) {
                 panic!("Tried to call outb in invalid runmode");
             }
         }
-
-        check_for_host_error();
     }
 }
 

src/hyperlight_guest/src/host_function_call.rs

@@ -38,7 +38,6 @@ pub mod guest_function_call;
 pub mod guest_function_definition;
 pub mod guest_function_register;
 
-pub mod host_error;
 pub mod host_function_call;
 
 pub(crate) mod guest_logger;

src/hyperlight_guest/src/lib.rs

@@ -25,7 +25,6 @@ use std::cell::{BorrowError, BorrowMutError};
 use std::convert::Infallible;
 use std::error::Error;
 use std::num::TryFromIntError;
-use std::str::Utf8Error;
 use std::string::FromUtf8Error;
 use std::sync::{MutexGuard, PoisonError};
 use std::time::SystemTimeError;
@@ -87,14 +86,6 @@ pub enum HyperlightError {
     #[error("{0}")]
     Error(String),
 
-    /// Exception Data Length is incorrect
-    #[error("Exception Data Length is incorrect. Expected: {0}, Actual: {1}")]
-    ExceptionDataLengthIncorrect(i32, usize),
-
-    /// Exception Message is too big
-    #[error("Exception Message is too big. Max Size: {0}, Actual: {1}")]
-    ExceptionMessageTooBig(usize, usize),
-
     /// Execution violation
     #[error("Non-executable address {0:#x} tried to be executed")]
     ExecutionAccessViolation(u64),
@@ -171,10 +162,6 @@ pub enum HyperlightError {
     #[error("The flatbuffer is invalid")]
     InvalidFlatBuffer(#[from] InvalidFlatbuffer),
 
-    /// Conversion of str to Json failed
-    #[error("Conversion of str data to json failed")]
-    JsonConversionFailure(#[from] serde_json::Error),
-
     /// Error occurred in KVM Operation
     #[error("KVM Error {0:?}")]
     #[cfg(kvm)]
@@ -225,10 +212,6 @@ pub enum HyperlightError {
     #[error("Restore_state called with no valid snapshot")]
     NoMemorySnapshot,
 
-    /// An error occurred handling an outb message
-    #[error("An error occurred handling an outb message {0:?}: {1}")]
-    OutBHandlingError(String, String),
-
     /// Failed to get value from parameter value
     #[error("Failed To Convert Parameter Value {0:?} to {1:?}")]
     ParameterValueConversionFailure(ParameterValue, &'static str),
@@ -292,10 +275,6 @@ pub enum HyperlightError {
     #[error("The return value type is unexpected got {0:?} expected {1:?}")]
     UnexpectedReturnValueType(ReturnValue, String),
 
-    /// Slice conversion to UTF8 failed
-    #[error("Slice Conversion of UTF8 data to str failed")]
-    UTF8SliceConversionFailure(#[from] Utf8Error),
-
     /// Slice conversion to UTF8 failed
     #[error("String Conversion of UTF8 data to str failed")]
     UTF8StringConversionFailure(#[from] FromUtf8Error),

src/hyperlight_host/src/error.rs

@@ -16,7 +16,7 @@ limitations under the License.
 
 use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode;
 
-use crate::error::HyperlightError::{GuestError, OutBHandlingError, StackOverflow};
+use crate::error::HyperlightError::{GuestError, StackOverflow};
 use crate::mem::shared_mem::HostSharedMemory;
 use crate::metrics::{METRIC_GUEST_ERROR, METRIC_GUEST_ERROR_LABEL_CODE};
 use crate::sandbox::mem_mgr::MemMgrWrapper;
@@ -27,18 +27,6 @@ pub(crate) fn check_for_guest_error(mgr: &MemMgrWrapper<HostSharedMemory>) -> Re
     let guest_err = mgr.as_ref().get_guest_error()?;
     match guest_err.code {
         ErrorCode::NoError => Ok(()),
-        ErrorCode::OutbError => match mgr.as_ref().get_host_error()? {
-            Some(host_err) => {
-                metrics::counter!(METRIC_GUEST_ERROR, METRIC_GUEST_ERROR_LABEL_CODE => (guest_err.code as u64).to_string()).increment(1);
-
-                log_then_return!(OutBHandlingError(
-                    host_err.source.clone(),
-                    guest_err.message.clone()
-                ));
-            }
-            // TODO: Not sure this is correct behavior. We should probably return error here
-            None => Ok(()),
-        },
         ErrorCode::StackOverflow => {
             metrics::counter!(METRIC_GUEST_ERROR, METRIC_GUEST_ERROR_LABEL_CODE => (guest_err.code as u64).to_string()).increment(1);
             log_then_return!(StackOverflow());

src/hyperlight_host/src/func/guest_err.rs

@@ -22,8 +22,8 @@ use rand::{rng, RngCore};
 use tracing::{instrument, Span};
 
 use super::memory_region::MemoryRegionType::{
-    Code, GuardPage, GuestErrorData, Heap, HostExceptionData, InputData, OutputData, PageTables,
-    PanicContext, Peb, Stack,
+    Code, GuardPage, GuestErrorData, Heap, InputData, OutputData, PageTables, PanicContext, Peb,
+    Stack,
 };
 use super::memory_region::{MemoryRegion, MemoryRegionFlags, MemoryRegionVecBuilder};
 use super::mgr::AMOUNT_OF_MEMORY_PER_PT;
@@ -47,8 +47,6 @@ use crate::{log_then_return, new_error, Result};
 // +-------------------------------------------+
 // |           Guest Error Log                 |
 // +-------------------------------------------+
-// |        Host Exception Handlers            |
-// +-------------------------------------------+
 // |                PEB Struct                 | (HyperlightPEB size)
 // +-------------------------------------------+
 // |               Guest Code                  |
@@ -62,12 +60,6 @@ use crate::{log_then_return, new_error, Result};
 // |                   PML4                    |
 // +-------------------------------------------+ 0x0_000
 
-///
-/// - `HostExceptionData` - memory that contains details of any Host Exception that
-///   occurred in outb function. it contains a 32 bit length following by a json
-///   serialisation of any error that occurred. the length of this field is
-///   `HostExceptionSize` from` `SandboxConfiguration`
-///
 /// - `GuestError` - contains a buffer for any guest error that occurred.
 ///   the length of this field is `GuestErrorBufferSize` from `SandboxConfiguration`
 ///
@@ -103,7 +95,6 @@ pub(crate) struct SandboxMemoryLayout {
     peb_offset: usize,
     peb_security_cookie_seed_offset: usize,
     peb_guest_dispatch_function_ptr_offset: usize, // set by guest in guest entrypoint
-    pub(crate) peb_host_exception_offset: usize,
     peb_guest_error_offset: usize,
     peb_code_and_outb_pointer_offset: usize,
     peb_runmode_offset: usize,
@@ -115,7 +106,6 @@ pub(crate) struct SandboxMemoryLayout {
 
     // The following are the actual values
     // that are written to the PEB struct
-    pub(crate) host_exception_buffer_offset: usize,
     pub(super) guest_error_buffer_offset: usize,
     pub(super) input_data_buffer_offset: usize,
     pub(super) output_data_buffer_offset: usize,
@@ -153,10 +143,6 @@ impl Debug for SandboxMemoryLayout {
                 "Guest Dispatch Function Pointer Offset",
                 &format_args!("{:#x}", self.peb_guest_dispatch_function_ptr_offset),
             )
-            .field(
-                "Host Exception Offset",
-                &format_args!("{:#x}", self.peb_host_exception_offset),
-            )
             .field(
                 "Guest Error Offset",
                 &format_args!("{:#x}", self.peb_guest_error_offset),
@@ -185,10 +171,6 @@ impl Debug for SandboxMemoryLayout {
                 "Guest Stack Offset",
                 &format_args!("{:#x}", self.peb_guest_stack_data_offset),
             )
-            .field(
-                "Host Exception Buffer Offset",
-                &format_args!("{:#x}", self.host_exception_buffer_offset),
-            )
             .field(
                 "Guest Error Buffer Offset",
                 &format_args!("{:#x}", self.guest_error_buffer_offset),
@@ -277,7 +259,6 @@ impl SandboxMemoryLayout {
             peb_offset + offset_of!(HyperlightPEB, security_cookie_seed);
         let peb_guest_dispatch_function_ptr_offset =
             peb_offset + offset_of!(HyperlightPEB, guest_function_dispatch_ptr);
-        let peb_host_exception_offset = peb_offset + offset_of!(HyperlightPEB, hostException);
         let peb_guest_error_offset = peb_offset + offset_of!(HyperlightPEB, guestErrorData);
         let peb_code_and_outb_pointer_offset = peb_offset + offset_of!(HyperlightPEB, pCode);
         let peb_runmode_offset = peb_offset + offset_of!(HyperlightPEB, runMode);
@@ -291,13 +272,8 @@ impl SandboxMemoryLayout {
         // The following offsets are the actual values that relate to memory layout,
         // which are written to PEB struct
         let peb_address = Self::BASE_ADDRESS + peb_offset;
-        // make sure host exception buffer starts at 4K boundary
-        let host_exception_buffer_offset = round_up_to(
-            peb_guest_stack_data_offset + size_of::<GuestStackData>(),
-            PAGE_SIZE_USIZE,
-        );
         let guest_error_buffer_offset = round_up_to(
-            host_exception_buffer_offset + cfg.get_host_exception_size(),
+            peb_guest_stack_data_offset + size_of::<GuestStackData>(),
             PAGE_SIZE_USIZE,
         );
         let input_data_buffer_offset = round_up_to(
@@ -329,7 +305,6 @@ impl SandboxMemoryLayout {
             heap_size,
             peb_security_cookie_seed_offset,
             peb_guest_dispatch_function_ptr_offset,
-            peb_host_exception_offset,
             peb_guest_error_offset,
             peb_code_and_outb_pointer_offset,
             peb_runmode_offset,
@@ -341,7 +316,6 @@ impl SandboxMemoryLayout {
             guest_error_buffer_offset,
             sandbox_memory_config: cfg,
             code_size,
-            host_exception_buffer_offset,
             input_data_buffer_offset,
             output_data_buffer_offset,
             guest_heap_buffer_offset,
@@ -359,14 +333,6 @@ impl SandboxMemoryLayout {
         self.peb_runmode_offset
     }
 
-    /// Get the offset in guest memory to the size field in the
-    /// `HostExceptionData` structure.
-    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
-    pub(super) fn get_host_exception_size_offset(&self) -> usize {
-        // The size field is the first field in the `HostExceptionData` struct
-        self.peb_host_exception_offset
-    }
-
     /// Get the offset in guest memory to the max size of the guest error buffer
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     pub(super) fn get_guest_error_buffer_size_offset(&self) -> usize {
@@ -398,12 +364,6 @@ impl SandboxMemoryLayout {
         self.stack_size
     }
 
-    /// Get the offset in guest memory to the start of host errors
-    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
-    pub(super) fn get_host_exception_offset(&self) -> usize {
-        self.host_exception_buffer_offset
-    }
-
     /// Get the offset in guest memory to the OutB pointer.
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     pub(super) fn get_outb_pointer_offset(&self) -> usize {
@@ -582,7 +542,6 @@ impl SandboxMemoryLayout {
         let mut total_mapped_memory_size: usize = round_up_to(code_size, PAGE_SIZE_USIZE);
         total_mapped_memory_size += round_up_to(stack_size, PAGE_SIZE_USIZE);
         total_mapped_memory_size += round_up_to(heap_size, PAGE_SIZE_USIZE);
-        total_mapped_memory_size += round_up_to(cfg.get_host_exception_size(), PAGE_SIZE_USIZE);
         total_mapped_memory_size += round_up_to(cfg.get_guest_error_buffer_size(), PAGE_SIZE_USIZE);
         total_mapped_memory_size += round_up_to(cfg.get_input_data_size(), PAGE_SIZE_USIZE);
         total_mapped_memory_size += round_up_to(cfg.get_output_data_size(), PAGE_SIZE_USIZE);
@@ -667,36 +626,18 @@ impl SandboxMemoryLayout {
         }
 
         // PEB
-        let host_exception_offset = builder.push_page_aligned(
+        let guest_error_offset = builder.push_page_aligned(
             size_of::<HyperlightPEB>(),
             MemoryRegionFlags::READ | MemoryRegionFlags::WRITE,
             Peb,
         );
 
-        let expected_host_exception_offset =
-            TryInto::<usize>::try_into(self.host_exception_buffer_offset)?;
-
-        if host_exception_offset != expected_host_exception_offset {
-            return Err(new_error!(
-                "Host Exception offset does not match expected Host Exception offset expected:  {}, actual:  {}",
-                expected_host_exception_offset,
-                host_exception_offset
-            ));
-        }
-
-        // host exception
-        let guest_error_offset = builder.push_page_aligned(
-            self.sandbox_memory_config.get_host_exception_size(),
-            MemoryRegionFlags::READ | MemoryRegionFlags::WRITE,
-            HostExceptionData,
-        );
-
         let expected_guest_error_offset =
             TryInto::<usize>::try_into(self.guest_error_buffer_offset)?;
 
         if guest_error_offset != expected_guest_error_offset {
             return Err(new_error!(
-                "Guest Error offset does not match expected Guest Error offset expected:  {}, actual:  {}",
+                "Guest error offset does not match expected Guest error offset expected:  {}, actual:  {}",
                 expected_guest_error_offset,
                 guest_error_offset
             ));
@@ -877,16 +818,6 @@ impl SandboxMemoryLayout {
 
         // Skip guest_dispatch_function_ptr_offset because it is set by the guest
 
-        // Set up Host Exception Header
-        // The peb only needs to include the size, not the actual buffer
-        // since the the guest wouldn't want to read the buffer anyway
-        shared_mem.write_u64(
-            self.get_host_exception_size_offset(),
-            self.sandbox_memory_config
-                .get_host_exception_size()
-                .try_into()?,
-        )?;
-
         // Set up Guest Error Fields
         let addr = get_address!(guest_error_buffer);
         shared_mem.write_u64(self.get_guest_error_buffer_pointer_offset(), addr)?;
@@ -1027,8 +958,6 @@ mod tests {
 
         expected_size += round_up_to(size_of::<HyperlightPEB>(), PAGE_SIZE_USIZE);
 
-        expected_size += round_up_to(cfg.get_host_exception_size(), PAGE_SIZE_USIZE);
-
         expected_size += round_up_to(cfg.get_guest_error_buffer_size(), PAGE_SIZE_USIZE);
 
         expected_size += round_up_to(cfg.get_input_data_size(), PAGE_SIZE_USIZE);

src/hyperlight_host/src/mem/layout.rs

@@ -131,8 +131,6 @@ pub enum MemoryRegionType {
     Code,
     /// The region contains the PEB
     Peb,
-    /// The region contains the Host Exception Data
-    HostExceptionData,
     /// The region contains the Guest Error Data
     GuestErrorData,
     /// The region contains the Input Data