Revert "Merge pull request #626 from benaubin/custom-run-async-future" (#643)

This reverts commit bf24022, reversing
changes made to ddaf91e.

Author: Pat Hickey

lucet-runtime/lucet-runtime-internals/src/future.rs

@@ -7,6 +7,7 @@ pub use crate::instance::execution::{KillError, KillState, KillSuccess, KillSwit
 pub use crate::instance::signals::{signal_handler_none, SignalBehavior, SignalHandler};
 pub use crate::instance::state::State;
 
+use crate::alloc::Alloc;
 use crate::context::Context;
 use crate::embed_ctx::CtxMap;
 use crate::error::Error;
@@ -17,13 +18,13 @@ use crate::region::RegionInternal;
 use crate::sysdeps::HOST_PAGE_SIZE_EXPECTED;
 use crate::val::{UntypedRetVal, Val};
 use crate::WASM_PAGE_SIZE;
-use crate::{alloc::Alloc, future::AsyncContext};
 use libc::{c_void, pthread_self, siginfo_t, uintptr_t};
 use lucet_module::InstanceRuntimeData;
 use memoffset::offset_of;
 use std::any::Any;
 use std::cell::{BorrowError, BorrowMutError, Ref, RefCell, RefMut, UnsafeCell};
 use std::convert::TryFrom;
+use std::marker::PhantomData;
 use std::mem;
 use std::ops::{Deref, DerefMut};
 use std::ptr::{self, NonNull};
@@ -514,7 +515,7 @@ impl Instance {
     /// in the future.
     pub fn run(&mut self, entrypoint: &str, args: &[Val]) -> Result<RunResult, Error> {
         let func = self.module.get_export_func(entrypoint)?;
-        Ok(self.run_func(func, &args, None, None)?.unwrap())
+        Ok(self.run_func(func, &args, false, None)?.unwrap())
     }
 
     /// Run a function with arguments in the guest context from the [WebAssembly function
@@ -530,7 +531,7 @@ impl Instance {
         args: &[Val],
     ) -> Result<RunResult, Error> {
         let func = self.module.get_func_from_idx(table_idx, func_idx)?;
-        Ok(self.run_func(func, &args, None, None)?.unwrap())
+        Ok(self.run_func(func, &args, false, None)?.unwrap())
     }
 
     /// Resume execution of an instance that has yielded without providing a value to the guest.
@@ -561,21 +562,19 @@ impl Instance {
     /// The foreign code safety caveat of [`Instance::run()`](struct.Instance.html#method.run)
     /// applies.
     pub fn resume_with_val<A: Any + 'static>(&mut self, val: A) -> Result<RunResult, Error> {
-        Ok(self
-            .resume_with_val_impl(Box::new(val), None, None)?
-            .unwrap())
+        Ok(self.resume_with_val_impl(val, false, None)?.unwrap())
     }
 
-    pub(crate) fn resume_with_val_impl(
+    pub(crate) fn resume_with_val_impl<A: Any + 'static>(
         &mut self,
-        val: Box<dyn Any + 'static>,
-        async_context: Option<AsyncContext>,
+        val: A,
+        async_context: bool,
         max_insn_count: Option<u64>,
     ) -> Result<InternalRunResult, Error> {
         match &self.state {
             State::Yielded { expecting, .. } => {
                 // make sure the resumed value is of the right type
-                if &(*val).type_id() != expecting {
+                if !expecting.is::<PhantomData<A>>() {
                     return Err(Error::InvalidArgument(
                         "type mismatch between yielded instance expected value and resumed value",
                     ));
@@ -584,7 +583,7 @@ impl Instance {
             _ => return Err(Error::InvalidArgument("can only resume a yielded instance")),
         }
 
-        self.resumed_val = Some(val);
+        self.resumed_val = Some(Box::new(val) as Box<dyn Any + 'static>);
 
         self.set_instruction_bound_delta(max_insn_count);
         self.swap_and_return(async_context)
@@ -603,7 +602,6 @@ impl Instance {
     /// applies.
     pub(crate) fn resume_bounded(
         &mut self,
-        async_context: AsyncContext,
         max_insn_count: u64,
     ) -> Result<InternalRunResult, Error> {
         if !self.state.is_bound_expired() {
@@ -612,7 +610,7 @@ impl Instance {
             ));
         }
         self.set_instruction_bound_delta(Some(max_insn_count));
-        self.swap_and_return(Some(async_context))
+        self.swap_and_return(true)
     }
 
     /// Run the module's [start function][start], if one exists.
@@ -650,7 +648,7 @@ impl Instance {
             if !self.is_not_started() {
                 return Err(Error::StartAlreadyRun);
             }
-            self.run_func(start, &[], None, None)?;
+            self.run_func(start, &[], false, None)?;
         }
         Ok(())
     }
@@ -1092,7 +1090,7 @@ impl Instance {
         &mut self,
         func: FunctionHandle,
         args: &[Val],
-        async_context: Option<AsyncContext>,
+        async_context: bool,
         inst_count_bound: Option<u64>,
     ) -> Result<InternalRunResult, Error> {
         let needs_start = self.state.is_not_started() && !func.is_start_func;
@@ -1193,10 +1191,7 @@ impl Instance {
     /// This must only be called for an instance in a ready, non-fatally faulted, or yielded state,
     /// or in the not-started state on the start function. The public wrappers around this function
     /// should make sure the state is appropriate.
-    fn swap_and_return<'a>(
-        &mut self,
-        async_context: Option<AsyncContext>,
-    ) -> Result<InternalRunResult, Error> {
+    fn swap_and_return(&mut self, async_context: bool) -> Result<InternalRunResult, Error> {
         let is_start_func = self
             .entrypoint
             .expect("we always have an entrypoint by now")
@@ -1208,10 +1203,7 @@ impl Instance {
                 || self.state.is_yielded()
                 || self.state.is_bound_expired()
         );
-
-        self.state = State::Running {
-            async_context: async_context.map(|cx| Arc::new(cx)),
-        };
+        self.state = State::Running { async_context };
 
         let res = self.with_current_instance(|i| {
             i.with_signals_on(|i| {

lucet-runtime/lucet-runtime-internals/src/instance.rs

@@ -1,8 +1,8 @@
+use crate::instance::siginfo_ext::SiginfoExt;
 use crate::instance::{FaultDetails, TerminationDetails, YieldedVal};
 use crate::sysdeps::UContext;
-use crate::{future::AsyncContext, instance::siginfo_ext::SiginfoExt};
 use libc::{SIGBUS, SIGSEGV};
-use std::any::TypeId;
+use std::any::Any;
 use std::ffi::{CStr, CString};
 
 /// The representation of a Lucet instance's state machine.
@@ -25,7 +25,7 @@ pub enum State {
     Running {
         /// Indicates whether the instance is running in an async context (`Instance::run_async`)
         /// or not. Needed by `Vmctx::block_on`.
-        async_context: Option<std::sync::Arc<AsyncContext>>,
+        async_context: bool,
     },
 
     /// The instance has faulted, potentially fatally.
@@ -56,8 +56,11 @@ pub enum State {
     /// `RunResult` before anything else happens to the instance.
     Yielding {
         val: YieldedVal,
-        /// The type of the expected resumption value
-        expecting: TypeId,
+        /// A phantom value carrying the type of the expected resumption value.
+        ///
+        /// Concretely, this should only ever be `Box<PhantomData<R>>` where `R` is the type
+        /// the guest expects upon resumption.
+        expecting: Box<dyn Any>,
     },
 
     /// The instance has yielded.
@@ -66,7 +69,10 @@ pub enum State {
     /// instance is reset.
     Yielded {
         /// A phantom value carrying the type of the expected resumption value.
-        expecting: TypeId,
+        ///
+        /// Concretely, this should only ever be `Box<PhantomData<R>>` where `R` is the type
+        /// the guest expects upon resumption.
+        expecting: Box<dyn Any>,
     },
 
     /// The instance has reached an instruction-count bound.
@@ -91,10 +97,10 @@ impl std::fmt::Display for State {
             State::NotStarted => write!(f, "not started"),
             State::Ready => write!(f, "ready"),
             State::Running {
-                async_context: None,
+                async_context: false,
             } => write!(f, "running"),
             State::Running {
-                async_context: Some(_),
+                async_context: true,
             } => write!(f, "running (in async context)"),
             State::Faulted {
                 details, siginfo, ..
@@ -157,11 +163,8 @@ impl State {
     }
 
     pub fn is_running_async(&self) -> bool {
-        if let State::Running {
-            async_context: Some(_),
-        } = self
-        {
-            true
+        if let State::Running { async_context } = self {
+            *async_context
         } else {
             false
         }

lucet-runtime/lucet-runtime-internals/src/instance/state.rs

@@ -13,9 +13,10 @@ use crate::instance::{
     CURRENT_INSTANCE, HOST_CTX,
 };
 use lucet_module::{FunctionHandle, GlobalValue};
-use std::any::{Any, TypeId};
+use std::any::Any;
 use std::borrow::{Borrow, BorrowMut};
 use std::cell::{Ref, RefCell, RefMut};
+use std::marker::PhantomData;
 
 /// An opaque handle to a running instance's context.
 #[derive(Debug)]
@@ -435,9 +436,10 @@ impl Vmctx {
         if is_bound_expiration {
             inst.state = State::BoundExpired;
         } else {
+            let expecting: Box<PhantomData<R>> = Box::new(PhantomData);
             inst.state = State::Yielding {
                 val: YieldedVal::new(val),
-                expecting: TypeId::of::<R>(),
+                expecting: expecting as Box<dyn Any>,
             };
         }
 

lucet-runtime/lucet-runtime-internals/src/vmctx.rs

@@ -101,17 +101,6 @@ pub fn lucet_hostcall(_attr: TokenStream, item: TokenStream) -> TokenStream {
         quote! { lucet_runtime::TerminationDetails }
     };
 
-    let res_ident = quote::format_ident!("res");
-
-    let block_if_async = match raw_sig.asyncness.take() {
-        Some(_) => {
-            quote! { let #res_ident = vmctx.block_on(#res_ident); }
-        }
-        None => {
-            quote! {}
-        }
-    };
-
     let raw_hostcall = quote! {
         #(#attrs)*
         #vis
@@ -122,13 +111,7 @@ pub fn lucet_hostcall(_attr: TokenStream, item: TokenStream) -> TokenStream {
             let vmctx = #vmctx_mod::Vmctx::from_raw(vmctx_raw);
             #vmctx_mod::VmctxInternal::instance_mut(&vmctx).uninterruptable(|| {
                 let res = std::panic::catch_unwind(move || {
-                    let vmctx = #vmctx_mod::Vmctx::from_raw(vmctx_raw);
-
-                    let #res_ident = #hostcall_ident(&vmctx, #(#impl_args),*);
-
-                    #block_if_async
-
-                    #res_ident
+                    #hostcall_ident(&#vmctx_mod::Vmctx::from_raw(vmctx_raw), #(#impl_args),*)
                 });
                 match res {
                     Ok(res) => res,

lucet-runtime/lucet-runtime-macros/src/lib.rs

@@ -1,8 +1,5 @@
 {
     "env": {
-        "hostcall_containing_block_on": "hostcall_containing_block_on",
-        "hostcall_containing_yielding_block_on": "hostcall_containing_yielding_block_on",
-        "hostcall_async_containing_yielding_block_on": "hostcall_async_containing_yielding_block_on",
-        "await_manual_future": "await_manual_future"
+        "hostcall_containing_block_on": "hostcall_containing_block_on"
     }
 }

lucet-runtime/lucet-runtime-tests/guests/async_hostcall/bindings.json

@@ -1,30 +1,9 @@
 #include <stddef.h>
 
 extern void hostcall_containing_block_on(int);
-extern void hostcall_containing_yielding_block_on(int);
-extern int hostcall_async_containing_yielding_block_on(int, int);
 
 int main(void)
 {
     hostcall_containing_block_on(1312);
     return 0;
 }
-
-int yielding()
-{
-    hostcall_containing_yielding_block_on(0);
-    hostcall_containing_yielding_block_on(1);
-    hostcall_containing_yielding_block_on(2);
-    hostcall_containing_yielding_block_on(3);
-
-    int six = hostcall_async_containing_yielding_block_on(3, 6);
-    hostcall_async_containing_yielding_block_on(3, six);
-
-    return 0;
-}
-
-int manual_future()
-{
-    await_manual_future();
-    return 0;
-}