remove dead code

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

Author: jprendes

src/hyperlight_host/src/func/call_ctx.rs

@@ -47,15 +47,6 @@ impl MultiUseGuestCallContext {
     pub fn start(sbox: MultiUseSandbox) -> Self {
         Self { sbox }
     }
-
-    /// Close out the context and get back the internally-stored
-    /// `MultiUseSandbox`. Future contexts opened by the returned sandbox
-    /// will have guest state restored.
-    #[instrument(err(Debug), skip(self), parent = Span::current())]
-    pub fn finish(mut self) -> Result<MultiUseSandbox> {
-        self.sbox.restore_state()?;
-        Ok(self.sbox)
-    }
 }
 
 impl Callable for MultiUseGuestCallContext {
@@ -96,8 +87,6 @@ mod tests {
 
     use hyperlight_testing::simple_guest_as_string;
 
-    use super::MultiUseGuestCallContext;
-    use crate::sandbox::Callable;
     use crate::sandbox_state::sandbox::EvolvableSandbox;
     use crate::sandbox_state::transition::Noop;
     use crate::{GuestBinary, HyperlightError, MultiUseSandbox, Result, UninitializedSandbox};
@@ -134,12 +123,12 @@ mod tests {
         // requests to execute batches of calls
         let recv_hdl = thread::spawn(move || {
             let mut sbox: MultiUseSandbox = new_uninit().unwrap().evolve(Noop::default()).unwrap();
+            let snapshot = sbox.snapshot().unwrap();
             while let Ok(calls) = recv.recv() {
-                let mut ctx = sbox.new_call_context();
                 for call in calls {
-                    call.call(&mut ctx);
+                    call.call(&mut sbox);
                 }
-                sbox = ctx.finish().unwrap();
+                sbox.restore(&snapshot).unwrap();
             }
         });
 
@@ -151,11 +140,15 @@ mod tests {
                     let calls = vec![
                         TestFuncCall::new(move |ctx| {
                             let msg = format!("Hello {}", i);
-                            let ret: String = ctx.call("Echo", msg.clone()).unwrap();
+                            let ret: String = ctx
+                                .call_guest_function_by_name("Echo", msg.clone())
+                                .unwrap();
                             assert_eq!(ret, msg)
                         }),
                         TestFuncCall::new(move |ctx| {
-                            let ret: i32 = ctx.call("CallMalloc", i + 2).unwrap();
+                            let ret: i32 = ctx
+                                .call_guest_function_by_name("CallMalloc", i + 2)
+                                .unwrap();
                             assert_eq!(ret, i + 2)
                         }),
                     ];
@@ -187,7 +180,9 @@ mod tests {
             let snapshot = self.sandbox.snapshot()?;
             let mut sum: i32 = 0;
             for n in 0..i {
-                let result = self.sandbox.call_guest_function_by_name::<i32>("AddToStatic", n);
+                let result = self
+                    .sandbox
+                    .call_guest_function_by_name::<i32>("AddToStatic", n);
                 sum += n;
                 println!("{:?}", result);
                 let result = result.unwrap();
@@ -226,14 +221,14 @@ mod tests {
         assert!(result.is_ok());
     }
 
-    struct TestFuncCall(Box<dyn FnOnce(&mut MultiUseGuestCallContext) + Send>);
+    struct TestFuncCall(Box<dyn FnOnce(&mut MultiUseSandbox) + Send>);
 
     impl TestFuncCall {
-        fn new(f: impl FnOnce(&mut MultiUseGuestCallContext) + Send + 'static) -> Self {
+        fn new(f: impl FnOnce(&mut MultiUseSandbox) + Send + 'static) -> Self {
             TestFuncCall(Box::new(f))
         }
 
-        fn call(self, ctx: &mut MultiUseGuestCallContext) {
+        fn call(self, ctx: &mut MultiUseSandbox) {
             (self.0)(ctx);
         }
     }

src/hyperlight_host/src/sandbox/initialized_multi_use.rs

@@ -285,15 +285,6 @@ impl MultiUseSandbox {
         })
     }
 
-    /// Restore the Sandbox's state
-    #[instrument(err(Debug), skip_all, parent = Span::current(), level = "Trace")]
-    pub(crate) fn restore_state(&mut self) -> Result<()> {
-        let mem_mgr = self.mem_mgr.unwrap_mgr_mut();
-        let rgns_to_unmap = mem_mgr.restore_state_from_last_snapshot()?;
-        unsafe { self.vm.unmap_regions(rgns_to_unmap)? };
-        Ok(())
-    }
-
     pub(crate) fn call_guest_function_by_name_no_reset(
         &mut self,
         function_name: &str,
@@ -327,8 +318,7 @@ impl MultiUseSandbox {
             self.check_stack_guard()?;
             check_for_guest_error(self.get_mgr_wrapper_mut())?;
 
-            self
-                .get_mgr_wrapper_mut()
+            self.get_mgr_wrapper_mut()
                 .as_mut()
                 .get_guest_function_call_result()
         })();