[host/sandbox/{config,uninit]] cleaned up legacy config options

Removed cfg options that became unused after PRs #451 , #453 , and #457 merged.

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

Author: danbugs

src/hyperlight_host/src/sandbox/config.rs

@@ -1,5 +1,3 @@
-// TODO(danbugs:297): forgot to remove stuff related to host exceptions and
-// host function definitions in my previous PR. Will remove them in the next commit.
 /*
 Copyright 2024 The Hyperlight Authors.
 
@@ -38,12 +36,6 @@ pub struct SandboxConfiguration {
     /// Guest gdb debug port
     #[cfg(gdb)]
     guest_debug_info: Option<DebugInfo>,
-    /// The size of the memory buffer that is made available for Guest Function
-    /// Definitions
-    host_function_definition_size: usize,
-    /// The size of the memory buffer that is made available for serialising
-    /// Host Exceptions
-    host_exception_size: usize,
     /// The size of the memory buffer that is made available for input to the
     /// Guest Binary
     input_data_size: usize,
@@ -64,10 +56,6 @@ pub struct SandboxConfiguration {
     /// field should be represented as an `Option`, that type is not
     /// FFI-safe, so it cannot be.
     heap_size_override: u64,
-    /// The kernel_stack_size to use in the guest sandbox. If set to 0, the default kernel stack size will be used.
-    /// The value will be increased to a multiple page size when memory is allocated if necessary.
-    ///
-    kernel_stack_size: usize,
     /// The max_execution_time of a guest execution in milliseconds. If set to 0, the max_execution_time
     /// will be set to the default value of 1000ms if the guest execution does not complete within the time specified
     /// then the execution will be cancelled, the minimum value is 1ms
@@ -107,16 +95,6 @@ impl SandboxConfiguration {
     pub const DEFAULT_OUTPUT_SIZE: usize = 0x4000;
     /// The minimum size of output data
     pub const MIN_OUTPUT_SIZE: usize = 0x2000;
-    /// The default size of host function definitions
-    /// Host function definitions has its own page in memory, in order to be READ-ONLY
-    /// from a guest's perspective.
-    pub const DEFAULT_HOST_FUNCTION_DEFINITION_SIZE: usize = 0x1000;
-    /// The minimum size of host function definitions
-    pub const MIN_HOST_FUNCTION_DEFINITION_SIZE: usize = 0x1000;
-    /// The default size for host exceptions
-    pub const DEFAULT_HOST_EXCEPTION_SIZE: usize = 0x4000;
-    /// The minimum size for host exceptions
-    pub const MIN_HOST_EXCEPTION_SIZE: usize = 0x4000;
     /// The default value for max initialization time (in milliseconds)
     pub const DEFAULT_MAX_INITIALIZATION_TIME: u16 = 2000;
     /// The minimum value for max initialization time (in milliseconds)
@@ -139,22 +117,15 @@ impl SandboxConfiguration {
     pub const DEFAULT_GUEST_PANIC_CONTEXT_BUFFER_SIZE: usize = 0x400;
     /// The minimum value for guest panic context data
     pub const MIN_GUEST_PANIC_CONTEXT_BUFFER_SIZE: usize = 0x400;
-    /// The minimum value for kernel stack size
-    pub const MIN_KERNEL_STACK_SIZE: usize = 0x1000;
-    /// The default value for kernel stack size
-    pub const DEFAULT_KERNEL_STACK_SIZE: usize = Self::MIN_KERNEL_STACK_SIZE;
 
     #[allow(clippy::too_many_arguments)]
     /// Create a new configuration for a sandbox with the given sizes.
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn new(
         input_data_size: usize,
         output_data_size: usize,
-        function_definition_size: usize,
-        host_exception_size: usize,
         stack_size_override: Option<u64>,
         heap_size_override: Option<u64>,
-        kernel_stack_size: usize,
         max_execution_time: Option<Duration>,
         max_initialization_time: Option<Duration>,
         max_wait_for_cancellation: Option<Duration>,
@@ -164,14 +135,8 @@ impl SandboxConfiguration {
         Self {
             input_data_size: max(input_data_size, Self::MIN_INPUT_SIZE),
             output_data_size: max(output_data_size, Self::MIN_OUTPUT_SIZE),
-            host_function_definition_size: max(
-                function_definition_size,
-                Self::MIN_HOST_FUNCTION_DEFINITION_SIZE,
-            ),
-            host_exception_size: max(host_exception_size, Self::MIN_HOST_EXCEPTION_SIZE),
             stack_size_override: stack_size_override.unwrap_or(0),
             heap_size_override: heap_size_override.unwrap_or(0),
-            kernel_stack_size: max(kernel_stack_size, Self::MIN_KERNEL_STACK_SIZE),
             max_execution_time: {
                 match max_execution_time {
                     Some(max_execution_time) => match max_execution_time.as_millis() {
@@ -242,23 +207,6 @@ impl SandboxConfiguration {
         self.output_data_size = max(output_data_size, Self::MIN_OUTPUT_SIZE);
     }
 
-    /// Set the size of the memory buffer that is made available for serialising host function definitions
-    /// the minimum value is MIN_HOST_FUNCTION_DEFINITION_SIZE
-    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
-    pub fn set_host_function_definition_size(&mut self, host_function_definition_size: usize) {
-        self.host_function_definition_size = max(
-            host_function_definition_size,
-            Self::MIN_HOST_FUNCTION_DEFINITION_SIZE,
-        );
-    }
-
-    /// Set the size of the memory buffer that is made available for serialising host exceptions
-    /// the minimum value is MIN_HOST_EXCEPTION_SIZE
-    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
-    pub fn set_host_exception_size(&mut self, host_exception_size: usize) {
-        self.host_exception_size = max(host_exception_size, Self::MIN_HOST_EXCEPTION_SIZE);
-    }
-
     /// Set the stack size to use in the guest sandbox. If set to 0, the stack size will be determined from the PE file header
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     pub fn set_stack_size(&mut self, stack_size: u64) {
@@ -271,13 +219,6 @@ impl SandboxConfiguration {
         self.heap_size_override = heap_size;
     }
 
-    /// Set the kernel stack size to use in the guest sandbox. If less than the minimum value of MIN_KERNEL_STACK_SIZE, the minimum value will be used.
-    /// If its not a multiple of the page size, it will be increased to the a multiple of the page size when memory is allocated.
-    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
-    pub fn set_kernel_stack_size(&mut self, kernel_stack_size: usize) {
-        self.kernel_stack_size = max(kernel_stack_size, Self::MIN_KERNEL_STACK_SIZE);
-    }
-
     /// Set the maximum execution time of a guest function execution. If set to 0, the max_execution_time
     /// will be set to the default value of DEFAULT_MAX_EXECUTION_TIME if the guest execution does not complete within the time specified
     /// then the execution will be cancelled, the minimum value is MIN_MAX_EXECUTION_TIME
@@ -350,16 +291,6 @@ impl SandboxConfiguration {
         self.guest_debug_info = Some(debug_info);
     }
 
-    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
-    pub(crate) fn get_host_function_definition_size(&self) -> usize {
-        self.host_function_definition_size
-    }
-
-    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
-    pub(crate) fn get_host_exception_size(&self) -> usize {
-        self.host_exception_size
-    }
-
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     pub(crate) fn get_input_data_size(&self) -> usize {
         self.input_data_size
@@ -413,11 +344,6 @@ impl SandboxConfiguration {
             .unwrap_or_else(|| exe_info.stack_reserve())
     }
 
-    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
-    pub(crate) fn get_kernel_stack_size(&self) -> usize {
-        self.kernel_stack_size
-    }
-
     /// If self.heap_size_override is non-zero, return it. Otherwise,
     /// return exe_info.heap_reserve()
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
@@ -433,11 +359,8 @@ impl Default for SandboxConfiguration {
         Self::new(
             Self::DEFAULT_INPUT_SIZE,
             Self::DEFAULT_OUTPUT_SIZE,
-            Self::DEFAULT_HOST_FUNCTION_DEFINITION_SIZE,
-            Self::DEFAULT_HOST_EXCEPTION_SIZE,
             None,
             None,
-            Self::DEFAULT_KERNEL_STACK_SIZE,
             None,
             None,
             None,
@@ -461,21 +384,15 @@ mod tests {
         const HEAP_SIZE_OVERRIDE: u64 = 0x50000;
         const INPUT_DATA_SIZE_OVERRIDE: usize = 0x4000;
         const OUTPUT_DATA_SIZE_OVERRIDE: usize = 0x4001;
-        const HOST_FUNCTION_DEFINITION_SIZE_OVERRIDE: usize = 0x4002;
-        const HOST_EXCEPTION_SIZE_OVERRIDE: usize = 0x4003;
         const MAX_EXECUTION_TIME_OVERRIDE: u16 = 1010;
         const MAX_WAIT_FOR_CANCELLATION_OVERRIDE: u8 = 200;
         const MAX_INITIALIZATION_TIME_OVERRIDE: u16 = 2000;
         const GUEST_PANIC_CONTEXT_BUFFER_SIZE_OVERRIDE: usize = 0x4005;
-        const KERNEL_STACK_SIZE_OVERRIDE: usize = 0x4000;
         let mut cfg = SandboxConfiguration::new(
             INPUT_DATA_SIZE_OVERRIDE,
             OUTPUT_DATA_SIZE_OVERRIDE,
-            HOST_FUNCTION_DEFINITION_SIZE_OVERRIDE,
-            HOST_EXCEPTION_SIZE_OVERRIDE,
             Some(STACK_SIZE_OVERRIDE),
             Some(HEAP_SIZE_OVERRIDE),
-            KERNEL_STACK_SIZE_OVERRIDE,
             Some(Duration::from_millis(MAX_EXECUTION_TIME_OVERRIDE as u64)),
             Some(Duration::from_millis(
                 MAX_INITIALIZATION_TIME_OVERRIDE as u64,
@@ -501,14 +418,8 @@ mod tests {
         cfg.heap_size_override = 2048;
         assert_eq!(1024, cfg.stack_size_override);
         assert_eq!(2048, cfg.heap_size_override);
-        assert_eq!(16384, cfg.kernel_stack_size);
         assert_eq!(INPUT_DATA_SIZE_OVERRIDE, cfg.input_data_size);
         assert_eq!(OUTPUT_DATA_SIZE_OVERRIDE, cfg.output_data_size);
-        assert_eq!(
-            HOST_FUNCTION_DEFINITION_SIZE_OVERRIDE,
-            cfg.host_function_definition_size
-        );
-        assert_eq!(HOST_EXCEPTION_SIZE_OVERRIDE, cfg.host_exception_size);
         assert_eq!(MAX_EXECUTION_TIME_OVERRIDE, cfg.max_execution_time);
         assert_eq!(
             MAX_WAIT_FOR_CANCELLATION_OVERRIDE,
@@ -529,11 +440,8 @@ mod tests {
         let mut cfg = SandboxConfiguration::new(
             SandboxConfiguration::MIN_INPUT_SIZE - 1,
             SandboxConfiguration::MIN_OUTPUT_SIZE - 1,
-            SandboxConfiguration::MIN_HOST_FUNCTION_DEFINITION_SIZE - 1,
-            SandboxConfiguration::MIN_HOST_EXCEPTION_SIZE - 1,
             None,
             None,
-            SandboxConfiguration::MIN_KERNEL_STACK_SIZE - 1,
             Some(Duration::from_millis(
                 SandboxConfiguration::MIN_MAX_EXECUTION_TIME as u64,
             )),
@@ -549,18 +457,6 @@ mod tests {
         );
         assert_eq!(SandboxConfiguration::MIN_INPUT_SIZE, cfg.input_data_size);
         assert_eq!(SandboxConfiguration::MIN_OUTPUT_SIZE, cfg.output_data_size);
-        assert_eq!(
-            SandboxConfiguration::MIN_KERNEL_STACK_SIZE,
-            cfg.kernel_stack_size
-        );
-        assert_eq!(
-            SandboxConfiguration::MIN_HOST_FUNCTION_DEFINITION_SIZE,
-            cfg.host_function_definition_size
-        );
-        assert_eq!(
-            SandboxConfiguration::MIN_HOST_EXCEPTION_SIZE,
-            cfg.host_exception_size
-        );
         assert_eq!(0, cfg.stack_size_override);
         assert_eq!(0, cfg.heap_size_override);
         assert_eq!(
@@ -582,10 +478,6 @@ mod tests {
 
         cfg.set_input_data_size(SandboxConfiguration::MIN_INPUT_SIZE - 1);
         cfg.set_output_data_size(SandboxConfiguration::MIN_OUTPUT_SIZE - 1);
-        cfg.set_host_function_definition_size(
-            SandboxConfiguration::MIN_HOST_FUNCTION_DEFINITION_SIZE - 1,
-        );
-        cfg.set_host_exception_size(SandboxConfiguration::MIN_HOST_EXCEPTION_SIZE - 1);
         cfg.set_max_execution_time(Duration::from_millis(
             SandboxConfiguration::MIN_MAX_EXECUTION_TIME as u64,
         ));
@@ -601,14 +493,6 @@ mod tests {
 
         assert_eq!(SandboxConfiguration::MIN_INPUT_SIZE, cfg.input_data_size);
         assert_eq!(SandboxConfiguration::MIN_OUTPUT_SIZE, cfg.output_data_size);
-        assert_eq!(
-            SandboxConfiguration::MIN_HOST_FUNCTION_DEFINITION_SIZE,
-            cfg.host_function_definition_size
-        );
-        assert_eq!(
-            SandboxConfiguration::MIN_HOST_EXCEPTION_SIZE,
-            cfg.host_exception_size
-        );
         assert_eq!(
             SandboxConfiguration::MIN_MAX_EXECUTION_TIME,
             cfg.max_execution_time
@@ -631,20 +515,6 @@ mod tests {
         use crate::sandbox::config::DebugInfo;
 
         proptest! {
-            #[test]
-            fn host_function_definition_size(size in SandboxConfiguration::MIN_HOST_FUNCTION_DEFINITION_SIZE..=SandboxConfiguration::MIN_HOST_FUNCTION_DEFINITION_SIZE * 10) {
-                let mut cfg = SandboxConfiguration::default();
-                cfg.set_host_function_definition_size(size);
-                prop_assert_eq!(size, cfg.get_host_function_definition_size());
-            }
-
-            #[test]
-            fn host_exception_size(size in SandboxConfiguration::MIN_HOST_EXCEPTION_SIZE..=SandboxConfiguration::MIN_HOST_EXCEPTION_SIZE * 10) {
-                let mut cfg = SandboxConfiguration::default();
-                cfg.set_host_exception_size(size);
-                prop_assert_eq!(size, cfg.get_host_exception_size());
-            }
-
             #[test]
             fn input_data_size(size in SandboxConfiguration::MIN_INPUT_SIZE..=SandboxConfiguration::MIN_INPUT_SIZE * 10) {
                 let mut cfg = SandboxConfiguration::default();

src/hyperlight_host/src/sandbox/uninitialized.rs

@@ -434,8 +434,6 @@ mod tests {
             let mut cfg = SandboxConfiguration::default();
             cfg.set_input_data_size(0x1000);
             cfg.set_output_data_size(0x1000);
-            cfg.set_host_function_definition_size(0x1000);
-            cfg.set_host_exception_size(0x1000);
             cfg.set_stack_size(0x1000);
             cfg.set_heap_size(0x1000);
             cfg.set_max_execution_time(Duration::from_millis(1001));