Remove FunctionsMap

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

Author: jprendes

src/hyperlight_host/src/sandbox/host_funcs.rs

@@ -14,33 +14,25 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+use std::collections::HashMap;
 use std::io::{IsTerminal, Write};
 
 use hyperlight_common::flatbuffer_wrappers::function_types::{ParameterValue, ReturnValue};
 use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
 use tracing::{instrument, Span};
 
-use super::{ExtraAllowedSyscall, FunctionsMap};
+use super::ExtraAllowedSyscall;
 use crate::func::HyperlightFunction;
 use crate::HyperlightError::HostFunctionNotFound;
 use crate::{new_error, Result};
 
 #[derive(Default, Clone)]
 /// A Wrapper around details of functions exposed by the Host
 pub struct HostFuncsWrapper {
-    functions_map: FunctionsMap,
+    functions_map: HashMap<String, (HyperlightFunction, Option<Vec<ExtraAllowedSyscall>>)>,
 }
 
 impl HostFuncsWrapper {
-    #[instrument(skip_all, parent = Span::current(), level = "Trace")]
-    fn get_host_funcs(&self) -> &FunctionsMap {
-        &self.functions_map
-    }
-    #[instrument(skip_all, parent = Span::current(), level = "Trace")]
-    fn get_host_funcs_mut(&mut self) -> &mut FunctionsMap {
-        &mut self.functions_map
-    }
-
     /// Register a host function with the sandbox.
     #[instrument(err(Debug), skip_all, parent = Span::current(), level = "Trace")]
     pub(crate) fn register_host_function(
@@ -72,7 +64,7 @@ impl HostFuncsWrapper {
     #[instrument(err(Debug), skip_all, parent = Span::current(), level = "Trace")]
     pub(super) fn host_print(&mut self, msg: String) -> Result<i32> {
         let res = call_host_func_impl(
-            self.get_host_funcs(),
+            &self.functions_map,
             "HostPrint",
             vec![ParameterValue::String(msg)],
         )?;
@@ -92,7 +84,7 @@ impl HostFuncsWrapper {
         name: &str,
         args: Vec<ParameterValue>,
     ) -> Result<ReturnValue> {
-        call_host_func_impl(self.get_host_funcs(), name, args)
+        call_host_func_impl(&self.functions_map, name, args)
     }
 }
 
@@ -104,30 +96,28 @@ fn register_host_function_helper(
 ) -> Result<()> {
     if let Some(_syscalls) = extra_allowed_syscalls {
         #[cfg(all(feature = "seccomp", target_os = "linux"))]
-        self_
-            .get_host_funcs_mut()
-            .insert(name, func, Some(_syscalls));
+        self_.functions_map.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(name, func, None);
+        self_.functions_map.insert(name, (func, None));
     }
 
     Ok(())
 }
 
 #[instrument(err(Debug), skip_all, parent = Span::current(), level = "Trace")]
 fn call_host_func_impl(
-    host_funcs: &FunctionsMap,
+    host_funcs: &HashMap<String, (HyperlightFunction, Option<Vec<ExtraAllowedSyscall>>)>,
     name: &str,
     args: Vec<ParameterValue>,
 ) -> Result<ReturnValue> {
     // Inner function containing the common logic
     fn call_func(
-        host_funcs: &FunctionsMap,
+        host_funcs: &HashMap<String, (HyperlightFunction, Option<Vec<ExtraAllowedSyscall>>)>,
         name: &str,
         args: Vec<ParameterValue>,
     ) -> Result<ReturnValue> {

src/hyperlight_host/src/sandbox/mod.rs

@@ -45,8 +45,6 @@ pub mod uninitialized;
 /// initialized `Sandbox`es.
 pub(crate) mod uninitialized_evolve;
 
-use std::collections::HashMap;
-
 /// Re-export for `SandboxConfiguration` type
 pub use config::SandboxConfiguration;
 /// Re-export for the `MultiUseSandbox` type
@@ -60,7 +58,6 @@ pub use uninitialized::GuestBinary;
 pub use uninitialized::UninitializedSandbox;
 
 use self::mem_mgr::MemMgrWrapper;
-use crate::func::HyperlightFunction;
 use crate::hypervisor::hypervisor_handler::HypervisorHandler;
 #[cfg(target_os = "windows")]
 use crate::hypervisor::windows_hypervisor_platform;
@@ -86,49 +83,6 @@ pub fn is_supported_platform() -> bool {
 /// Alias for the type of extra allowed syscalls.
 pub type ExtraAllowedSyscall = i64;
 
-/// A `HashMap` to map function names to `HyperlightFunction`s and their extra allowed syscalls.
-///
-/// Note: you cannot add extra syscalls on Windows, but the field is still present to avoid a funky
-/// conditional compilation setup. This isn't a big deal as this struct isn't public facing.
-#[derive(Clone, Default)]
-pub(super) struct FunctionsMap(
-    HashMap<String, (HyperlightFunction, Option<Vec<ExtraAllowedSyscall>>)>,
-);
-
-impl FunctionsMap {
-    /// Insert a new entry into the map
-    pub(super) fn insert(
-        &mut self,
-        key: String,
-        value: HyperlightFunction,
-        extra_syscalls: Option<Vec<ExtraAllowedSyscall>>,
-    ) {
-        self.0.insert(key, (value, extra_syscalls));
-    }
-
-    /// Get the value associated with the given key, if it exists.
-    pub(super) fn get(
-        &self,
-        key: &str,
-    ) -> Option<&(HyperlightFunction, Option<Vec<ExtraAllowedSyscall>>)> {
-        self.0.get(key)
-    }
-
-    /// Get the length of the map.
-    fn len(&self) -> usize {
-        self.0.len()
-    }
-}
-
-impl PartialEq for FunctionsMap {
-    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
-    fn eq(&self, other: &Self) -> bool {
-        self.len() == other.len() && self.0.keys().all(|k| other.0.contains_key(k))
-    }
-}
-
-impl Eq for FunctionsMap {}
-
 /// Determine whether a suitable hypervisor is available to run
 /// this sandbox.
 ///