Use a struct instead of a tuple for HostFuncsWrapper

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

Author: jprendes

src/hyperlight_host/src/sandbox/host_funcs.rs

@@ -29,7 +29,13 @@ use crate::{new_error, Result};
 #[derive(Default, Clone)]
 /// A Wrapper around details of functions exposed by the Host
 pub struct HostFuncsWrapper {
-    functions_map: HashMap<String, (HyperlightFunction, Option<Vec<ExtraAllowedSyscall>>)>,
+    functions_map: HashMap<String, FunctionEntry>,
+}
+
+#[derive(Clone)]
+pub struct FunctionEntry {
+    pub function: HyperlightFunction,
+    pub extra_allowed_syscalls: Option<Vec<ExtraAllowedSyscall>>,
 }
 
 impl HostFuncsWrapper {
@@ -86,7 +92,7 @@ impl HostFuncsWrapper {
     fn register_host_function_helper(
         &mut self,
         name: String,
-        func: HyperlightFunction,
+        function: HyperlightFunction,
         extra_allowed_syscalls: Option<Vec<ExtraAllowedSyscall>>,
     ) -> Result<()> {
         #[cfg(not(all(feature = "seccomp", target_os = "linux")))]
@@ -95,16 +101,24 @@ impl HostFuncsWrapper {
                 "Extra syscalls are only supported on Linux with seccomp"
             ));
         }
-        self.functions_map
-            .insert(name, (func, extra_allowed_syscalls));
+        self.functions_map.insert(
+            name,
+            FunctionEntry {
+                function,
+                extra_allowed_syscalls,
+            },
+        );
         Ok(())
     }
 
     #[instrument(err(Debug), skip_all, parent = Span::current(), level = "Trace")]
     fn call_host_func_impl(&self, name: &str, args: Vec<ParameterValue>) -> Result<ReturnValue> {
         // Inner function containing the common logic
         let do_call = || {
-            let (func, syscalls) = self
+            let FunctionEntry {
+                function,
+                extra_allowed_syscalls,
+            } = self
                 .functions_map
                 .get(name)
                 .ok_or_else(|| HostFunctionNotFound(name.to_string()))?;
@@ -113,12 +127,12 @@ impl HostFuncsWrapper {
             {
                 let seccomp_filter =
                     crate::seccomp::guest::get_seccomp_filter_for_host_function_worker_thread(
-                        syscalls.clone(),
+                        extra_allowed_syscalls.clone(),
                     )?;
                 seccompiler::apply_filter(&seccomp_filter)?;
             }
 
-            crate::metrics::maybe_time_and_emit_host_call(name, || func.call(args))
+            crate::metrics::maybe_time_and_emit_host_call(name, || function.call(args))
         };
 
         // Create a new thread when seccomp is enabled on Linux