Fix memory leak in host function envs

examples/imports_function_env.rs

@@ -19,8 +19,7 @@
 //!
 //! Ready?
 
-use std::cell::RefCell;
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, WasmerEnv};
 use wasmer_compiler_cranelift::Cranelift;
 use wasmer_engine_jit::JIT;
@@ -57,11 +56,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let module = Module::new(&store, wasm_bytes)?;
 
     // We create some shared data here, `Arc` is required because we may
-    // move our WebAssembly instance to another thread to run it. RefCell
+    // move our WebAssembly instance to another thread to run it. Mutex
     // lets us get shared mutabilty which is fine because we know we won't
     // run host calls concurrently.  If concurrency is a possibilty, we'd have
     // to use a `Mutex`.
-    let shared_counter: Arc<RefCell<i32>> = Arc::new(RefCell::new(0));
+    let shared_counter: Arc<Mutex<i32>> = Arc::new(Mutex::new(0));
 
     // Once we have our counter we'll wrap it inside en `Env` which we'll pass
     // to our imported functions.
@@ -70,17 +69,17 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // possible to know the size of the `Env` at compile time (i.e it has to
     // implement the `Sized` trait) and that it implement the `WasmerEnv` trait.
     // We derive a default implementation of `WasmerEnv` here.
-    #[derive(WasmerEnv)]
+    #[derive(WasmerEnv, Clone)]
     struct Env {
-        counter: Arc<RefCell<i32>>,
+        counter: Arc<Mutex<i32>>,
     }
 
     // Create the functions
     fn get_counter(env: &Env) -> i32 {
-        *env.counter.borrow()
+        *env.counter.lock().unwrap()
     }
     fn add_to_counter(env: &Env, add: i32) -> i32 {
-        let mut counter_ref = env.counter.borrow_mut();
+        let mut counter_ref = env.counter.lock().unwrap();
 
         *counter_ref += add;
         *counter_ref
@@ -106,7 +105,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         .get_function("increment_counter_loop")?
         .native::<i32, i32>()?;
 
-    let counter_value: i32 = *shared_counter.borrow();
+    let counter_value: i32 = *shared_counter.lock().unwrap();
     println!("Initial ounter value: {:?}", counter_value);
 
     println!("Calling `increment_counter_loop` function...");
@@ -115,7 +114,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // It will loop five times thus incrementing our counter five times.
     let result = increment_counter_loop.call(5)?;
 
-    let counter_value: i32 = *shared_counter.borrow();
+    let counter_value: i32 = *shared_counter.lock().unwrap();
     println!("New counter value (host): {:?}", counter_value);
     assert_eq!(counter_value, 5);
 

lib/api/src/env.rs

@@ -30,12 +30,12 @@ impl From<ExportError> for HostEnvInitError {
 /// ```
 /// use wasmer::{WasmerEnv, LazyInit, Memory, NativeFunc};
 ///
-/// #[derive(WasmerEnv)]
+/// #[derive(WasmerEnv, Clone)]
 /// pub struct MyEnvWithNoInstanceData {
 ///     non_instance_data: u8,
 /// }
 ///
-/// #[derive(WasmerEnv)]
+/// #[derive(WasmerEnv, Clone)]
 /// pub struct MyEnvWithInstanceData {
 ///     non_instance_data: u8,
 ///     #[wasmer(export)]
@@ -54,6 +54,7 @@ impl From<ExportError> for HostEnvInitError {
 /// This trait can also be implemented manually:
 /// ```
 /// # use wasmer::{WasmerEnv, LazyInit, Memory, Instance, HostEnvInitError};
+/// #[derive(Clone)]
 /// pub struct MyEnv {
 ///    memory: LazyInit<Memory>,
 /// }
@@ -66,7 +67,7 @@ impl From<ExportError> for HostEnvInitError {
 ///     }
 /// }
 /// ```
-pub trait WasmerEnv {
+pub trait WasmerEnv: Clone + Send {
     /// The function that Wasmer will call on your type to let it finish
     /// setting up the environment with data from the `Instance`.
     ///
@@ -94,26 +95,26 @@ impl WasmerEnv for isize {}
 impl WasmerEnv for char {}
 impl WasmerEnv for bool {}
 impl WasmerEnv for String {}
-impl WasmerEnv for ::std::sync::atomic::AtomicBool {}
-impl WasmerEnv for ::std::sync::atomic::AtomicI8 {}
-impl WasmerEnv for ::std::sync::atomic::AtomicU8 {}
-impl WasmerEnv for ::std::sync::atomic::AtomicI16 {}
-impl WasmerEnv for ::std::sync::atomic::AtomicU16 {}
-impl WasmerEnv for ::std::sync::atomic::AtomicI32 {}
-impl WasmerEnv for ::std::sync::atomic::AtomicU32 {}
-impl WasmerEnv for ::std::sync::atomic::AtomicI64 {}
-impl WasmerEnv for ::std::sync::atomic::AtomicUsize {}
-impl WasmerEnv for ::std::sync::atomic::AtomicIsize {}
-impl WasmerEnv for dyn ::std::any::Any {}
+impl<'a> WasmerEnv for &'a ::std::sync::atomic::AtomicBool {}
+impl<'a> WasmerEnv for &'a ::std::sync::atomic::AtomicI8 {}
+impl<'a> WasmerEnv for &'a ::std::sync::atomic::AtomicU8 {}
+impl<'a> WasmerEnv for &'a ::std::sync::atomic::AtomicI16 {}
+impl<'a> WasmerEnv for &'a ::std::sync::atomic::AtomicU16 {}
+impl<'a> WasmerEnv for &'a ::std::sync::atomic::AtomicI32 {}
+impl<'a> WasmerEnv for &'a ::std::sync::atomic::AtomicU32 {}
+impl<'a> WasmerEnv for &'a ::std::sync::atomic::AtomicI64 {}
+impl<'a> WasmerEnv for &'a ::std::sync::atomic::AtomicUsize {}
+impl<'a> WasmerEnv for &'a ::std::sync::atomic::AtomicIsize {}
 impl<T: WasmerEnv> WasmerEnv for Box<T> {
     fn init_with_instance(&mut self, instance: &Instance) -> Result<(), HostEnvInitError> {
         (&mut **self).init_with_instance(instance)
     }
 }
 
-impl<T: WasmerEnv> WasmerEnv for &'static mut T {
+impl<T: WasmerEnv> WasmerEnv for ::std::sync::Arc<::std::sync::Mutex<T>> {
     fn init_with_instance(&mut self, instance: &Instance) -> Result<(), HostEnvInitError> {
-        (*self).init_with_instance(instance)
+        let mut guard = self.lock().unwrap();
+        guard.init_with_instance(instance)
     }
 }