Add trait to abstract over sandboxes in host function registration

This is useful to allow host-side code to work on both core Hyperlight
sandboxes and wrapped sandboxes like Hyperlight Wasm.

Signed-off-by: Lucy Menon <[email protected]>

Author: syntactically

src/hyperlight_host/src/func/host_functions.rs

@@ -23,6 +23,52 @@ use super::{ParameterTuple, ResultType, SupportedReturnType};
 use crate::sandbox::{ExtraAllowedSyscall, UninitializedSandbox};
 use crate::{log_then_return, new_error, Result};
 
+/// A sandbox on which (primitive) host functions can be registered
+///
+pub trait Registerable {
+    /// Register a primitive host function
+    fn register_host_function<Args: ParameterTuple, Output: SupportedReturnType>(
+        &mut self,
+        name: &str,
+        hf: impl Into<HostFunction<Output, Args>>,
+    ) -> Result<()>;
+    /// Register a primitive host function whose worker thread has
+    /// extra permissive seccomp filters installed
+    #[cfg(all(feature = "seccomp", target_os = "linux"))]
+    fn register_host_function_with_syscalls<Args: ParameterTuple, Output: SupportedReturnType>(
+        &mut self,
+        name: &str,
+        hf: impl Into<HostFunction<Output, Args>>,
+        eas: Vec<ExtraAllowedSyscall>,
+    ) -> Result<()>;
+}
+impl Registerable for UninitializedSandbox {
+    fn register_host_function<Args: ParameterTuple, Output: SupportedReturnType>(
+        &mut self,
+        name: &str,
+        hf: impl Into<HostFunction<Output, Args>>,
+    ) -> Result<()> {
+        let mut hfs = self
+            .host_funcs
+            .try_lock()
+            .map_err(|e| new_error!("Error locking at {}:{}: {}", file!(), line!(), e))?;
+        (*hfs).register_host_function(name.to_string(), hf.into().into())
+    }
+    #[cfg(all(feature = "seccomp", target_os = "linux"))]
+    fn register_host_function_with_syscalls<Args: ParameterTuple, Output: SupportedReturnType>(
+        &mut self,
+        name: &str,
+        hf: impl Into<HostFunction<Output, Args>>,
+        eas: Vec<ExtraAllowedSyscall>,
+    ) -> Result<()> {
+        let mut hfs = self
+            .host_funcs
+            .try_lock()
+            .map_err(|e| new_error!("Error locking at {}:{}: {}", file!(), line!(), e))?;
+        (*hfs).register_host_function_with_syscalls(name.to_string(), hf.into().into(), eas)
+    }
+}
+
 /// A representation of a host function.
 /// This is a thin wrapper around a `Fn(Args) -> Result<Output>`.
 #[derive(Clone)]

src/hyperlight_host/src/func/mod.rs

@@ -38,7 +38,7 @@ pub(crate) mod param_type;
 pub(crate) mod ret_type;
 
 /// Re-export for `HostFunction` trait
-pub use host_functions::HostFunction;
+pub use host_functions::{HostFunction, Registerable};
 /// Re-export for `ParameterValue` enum
 pub use hyperlight_common::flatbuffer_wrappers::function_types::ParameterValue;
 /// Re-export for `ReturnType` enum