remove unused FunctionDefinition

Signed-off-by: Jorge Prendes <[email protected]>

Author: jprendes

src/hyperlight_host/src/func/host_functions.rs

@@ -17,42 +17,14 @@ limitations under the License.
 #![allow(non_snake_case)]
 use std::sync::{Arc, Mutex};
 
-use hyperlight_common::flatbuffer_wrappers::function_types::{
-    ParameterType, ParameterValue, ReturnType,
-};
+use hyperlight_common::flatbuffer_wrappers::function_types::ParameterValue;
 use tracing::{instrument, Span};
 
 use super::{HyperlightFunction, SupportedParameterType, SupportedReturnType};
 use crate::sandbox::{ExtraAllowedSyscall, UninitializedSandbox};
 use crate::HyperlightError::UnexpectedNoOfArguments;
 use crate::{log_then_return, new_error, Result};
 
-/// The definition of a function exposed from the host to the guest
-#[derive(Debug, Default, Clone, PartialEq, Eq)]
-pub struct HostFunctionDefinition {
-    /// The function name
-    pub function_name: String,
-    /// The type of the parameter values for the host function call.
-    pub parameter_types: Option<Vec<ParameterType>>,
-    /// The type of the return value from the host function call
-    pub return_type: ReturnType,
-}
-
-impl HostFunctionDefinition {
-    /// Create a new `HostFunctionDefinition`.
-    pub fn new(
-        function_name: String,
-        parameter_types: Option<Vec<ParameterType>>,
-        return_type: ReturnType,
-    ) -> Self {
-        Self {
-            function_name,
-            parameter_types,
-            return_type,
-        }
-    }
-}
-
 /// Trait for registering a host function
 pub trait HostFunction<R, Args> {
     /// Register the host function with the given name in the sandbox.
@@ -181,8 +153,6 @@ macro_rules! impl_host_function {
                     Ok(result.into_value())
                 });
 
-                let parameter_types = Some(vec![$($P::TYPE),*]);
-
                 if let Some(_eas) = extra_allowed_syscalls {
                     if cfg!(all(feature = "seccomp", target_os = "linux")) {
                         // Register with extra allowed syscalls
@@ -193,11 +163,7 @@ macro_rules! impl_host_function {
                                 .try_lock()
                                 .map_err(|e| new_error!("Error locking at {}:{}: {}", file!(), line!(), e))?
                                 .register_host_function_with_syscalls(
-                                    &HostFunctionDefinition::new(
-                                        name.to_string(),
-                                        parameter_types,
-                                        R::TYPE,
-                                    ),
+                                    name.to_string(),
                                     HyperlightFunction::new(func),
                                     _eas,
                                 )?;
@@ -213,11 +179,7 @@ macro_rules! impl_host_function {
                         .try_lock()
                         .map_err(|e| new_error!("Error locking at {}:{}: {}", file!(), line!(), e))?
                         .register_host_function(
-                            &HostFunctionDefinition::new(
-                                name.to_string(),
-                                parameter_types,
-                                R::TYPE,
-                            ),
+                            name.to_string(),
                             HyperlightFunction::new(func),
                         )?;
                 }

src/hyperlight_host/src/sandbox/host_funcs.rs

@@ -21,18 +21,14 @@ use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
 use tracing::{instrument, Span};
 
 use super::{ExtraAllowedSyscall, FunctionsMap};
-use crate::func::host_functions::HostFunctionDefinition;
 use crate::func::HyperlightFunction;
 use crate::HyperlightError::HostFunctionNotFound;
 use crate::{new_error, Result};
 
-type HostFunctionDetails = Option<Vec<HostFunctionDefinition>>;
-
 #[derive(Default, Clone)]
 /// A Wrapper around details of functions exposed by the Host
 pub struct HostFuncsWrapper {
     functions_map: FunctionsMap,
-    function_details: HostFunctionDetails,
 }
 
 impl HostFuncsWrapper {
@@ -44,23 +40,15 @@ impl HostFuncsWrapper {
     fn get_host_funcs_mut(&mut self) -> &mut FunctionsMap {
         &mut self.functions_map
     }
-    #[instrument(skip_all, parent = Span::current(), level = "Trace")]
-    fn get_host_func_details(&self) -> &HostFunctionDetails {
-        &self.function_details
-    }
-    #[instrument(skip_all, parent = Span::current(), level = "Trace")]
-    fn get_host_func_details_mut(&mut self) -> &mut HostFunctionDetails {
-        &mut self.function_details
-    }
 
     /// Register a host function with the sandbox.
     #[instrument(err(Debug), skip_all, parent = Span::current(), level = "Trace")]
     pub(crate) fn register_host_function(
         &mut self,
-        hfd: &HostFunctionDefinition,
+        name: String,
         func: HyperlightFunction,
     ) -> Result<()> {
-        register_host_function_helper(self, hfd, func, None)
+        register_host_function_helper(self, name, func, None)
     }
 
     /// Register a host function with the sandbox, with a list of extra syscalls
@@ -69,11 +57,11 @@ impl HostFuncsWrapper {
     #[cfg(all(feature = "seccomp", target_os = "linux"))]
     pub(crate) fn register_host_function_with_syscalls(
         &mut self,
-        hfd: &HostFunctionDefinition,
+        name: String,
         func: HyperlightFunction,
         extra_allowed_syscalls: Vec<ExtraAllowedSyscall>,
     ) -> Result<()> {
-        register_host_function_helper(self, hfd, func, Some(extra_allowed_syscalls))
+        register_host_function_helper(self, name, func, Some(extra_allowed_syscalls))
     }
 
     /// Assuming a host function called `"HostPrint"` exists, and takes a
@@ -106,41 +94,27 @@ impl HostFuncsWrapper {
     ) -> Result<ReturnValue> {
         call_host_func_impl(self.get_host_funcs(), name, args)
     }
-
-    /// Insert a host function into the list of registered host functions.
-    pub(super) fn insert_host_function(&mut self, host_function: HostFunctionDefinition) {
-        match &mut self.function_details {
-            Some(host_functions) => host_functions.push(host_function),
-            None => {
-                let host_functions = Vec::from(&[host_function]);
-                self.function_details = Some(host_functions);
-            }
-        }
-    }
 }
 
 fn register_host_function_helper(
     self_: &mut HostFuncsWrapper,
-    hfd: &HostFunctionDefinition,
+    name: String,
     func: HyperlightFunction,
     extra_allowed_syscalls: Option<Vec<ExtraAllowedSyscall>>,
 ) -> Result<()> {
     if let Some(_syscalls) = extra_allowed_syscalls {
         #[cfg(all(feature = "seccomp", target_os = "linux"))]
         self_
             .get_host_funcs_mut()
-            .insert(hfd.function_name.to_string(), func, Some(_syscalls));
+            .insert(name, func, Some(_syscalls));
 
         #[cfg(not(all(feature = "seccomp", target_os = "linux")))]
         return Err(new_error!(
             "Extra syscalls are only supported on Linux with seccomp"
         ));
     } else {
-        self_
-            .get_host_funcs_mut()
-            .insert(hfd.function_name.to_string(), func, None);
+        self_.get_host_funcs_mut().insert(name, func, None);
     }
-    self_.insert_host_function(hfd.clone());
 
     Ok(())
 }