Keep module data alive for the lifetime of the runtime

Author: Veykril

src/environment.rs

@@ -1,4 +1,6 @@
+use alloc::boxed::Box;
 use alloc::rc::Rc;
+
 use core::ptr::NonNull;
 
 use crate::error::{Error, Result};
@@ -43,7 +45,7 @@ impl Environment {
 
     /// Parses a wasm module from raw bytes.
     #[inline]
-    pub fn parse_module(&self, bytes: &[u8]) -> Result<ParsedModule> {
+    pub fn parse_module<TData: Into<Box<[u8]>>>(&self, bytes: TData) -> Result<ParsedModule> {
         ParsedModule::parse(self, bytes)
     }
 

src/lib.rs

@@ -1,7 +1,5 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 #![warn(missing_docs)]
-#![warn(clippy::all)]
-#![allow(clippy::match_bool)]
 //! A rust wrapper for [WASM3](https://github.com/wasm3/wasm3).
 
 extern crate alloc;

src/module.rs

@@ -1,4 +1,6 @@
 use alloc::boxed::Box;
+
+use core::mem;
 use core::ptr::{self, NonNull};
 use core::slice;
 
@@ -11,24 +13,22 @@ use crate::wasm3_priv;
 
 /// A parsed module which can be loaded into a [`Runtime`].
 pub struct ParsedModule {
+    data: Box<[u8]>,
     raw: ffi::IM3Module,
     env: Environment,
 }
 
 impl ParsedModule {
     /// Parses a wasm module from raw bytes.
-    pub fn parse(env: &Environment, bytes: &[u8]) -> Result<Self> {
-        assert!(bytes.len() <= !0u32 as usize);
+    pub fn parse<TData: Into<Box<[u8]>>>(env: &Environment, data: TData) -> Result<Self> {
+        let data = data.into();
+        assert!(data.len() <= !0u32 as usize);
         let mut module = ptr::null_mut();
         let res = unsafe {
-            ffi::m3_ParseModule(
-                env.as_ptr(),
-                &mut module,
-                bytes.as_ptr(),
-                bytes.len() as u32,
-            )
+            ffi::m3_ParseModule(env.as_ptr(), &mut module, data.as_ptr(), data.len() as u32)
         };
         Error::from_ffi_res(res).map(|_| ParsedModule {
+            data,
             raw: module,
             env: env.clone(),
         })
@@ -38,6 +38,12 @@ impl ParsedModule {
         self.raw
     }
 
+    pub(crate) fn take_data(self) -> Box<[u8]> {
+        let res = unsafe { ptr::read(&self.data) };
+        mem::forget(self);
+        res
+    }
+
     /// The environment this module was parsed in.
     pub fn environment(&self) -> &Environment {
         &self.env
@@ -60,7 +66,10 @@ pub struct Module<'rt> {
 impl<'rt> Module<'rt> {
     /// Parses a wasm module from raw bytes.
     #[inline]
-    pub fn parse(environment: &Environment, bytes: &[u8]) -> Result<ParsedModule> {
+    pub fn parse<TData: Into<Box<[u8]>>>(
+        environment: &Environment,
+        bytes: TData,
+    ) -> Result<ParsedModule> {
         ParsedModule::parse(environment, bytes)
     }
 

src/runtime.rs

@@ -20,6 +20,8 @@ pub struct Runtime {
     environment: Environment,
     // holds all linked closures so that they properly get disposed of when runtime drops
     closure_store: UnsafeCell<Vec<PinnedAnyClosure>>,
+    // holds all backing data of loaded modules as they have to be kept alive for the module's lifetime
+    module_data: UnsafeCell<Vec<Box<[u8]>>>,
 }
 
 impl Runtime {
@@ -41,11 +43,15 @@ impl Runtime {
             raw,
             environment: environment.clone(),
             closure_store: UnsafeCell::new(Vec::new()),
+            module_data: UnsafeCell::new(Vec::new()),
         })
     }
 
     /// Parses and loads a module from bytes.
-    pub fn parse_and_load_module<'rt>(&'rt self, bytes: &[u8]) -> Result<Module<'rt>> {
+    pub fn parse_and_load_module<'rt, TData: Into<Box<[u8]>>>(
+        &'rt self,
+        bytes: TData,
+    ) -> Result<Module<'rt>> {
         Module::parse(&self.environment, bytes).and_then(|module| self.load_module(module))
     }
 
@@ -58,10 +64,13 @@ impl Runtime {
         if &self.environment != module.environment() {
             Err(Error::ModuleLoadEnvMismatch)
         } else {
-            Error::from_ffi_res(unsafe { ffi::m3_LoadModule(self.raw.as_ptr(), module.as_ptr()) })?;
-            let raw = module.as_ptr();
-            mem::forget(module);
-            Ok(Module::from_raw(self, raw))
+            let raw_mod = module.as_ptr();
+            Error::from_ffi_res(unsafe { ffi::m3_LoadModule(self.raw.as_ptr(), raw_mod) })?;
+            // SAFETY: Runtime isn't Send, therefor this access is single-threaded and kept alive only for the Vec::push call
+            // as such this can not alias.
+            unsafe { (*self.module_data.get()).push(module.take_data()) };
+
+            Ok(Module::from_raw(self, raw_mod))
         }
     }
 
@@ -76,7 +85,7 @@ impl Runtime {
     {
         self.modules()
             .find_map(|module| match module.find_function::<ARGS, RET>(name) {
-                res @ Ok(_) | res @ Err(Error::InvalidFunctionSignature) => Some(res),
+                res @ (Ok(_) | Err(Error::InvalidFunctionSignature)) => Some(res),
                 _ => None,
             })
             .unwrap_or(Err(Error::FunctionNotFound))

wasm3-sys/src/lib.rs

@@ -2,5 +2,6 @@
 #![allow(non_upper_case_globals)]
 #![allow(non_camel_case_types)]
 #![allow(non_snake_case)]
+#![allow(clippy::all)]
 
 include!(concat!(env!("OUT_DIR"), "/bindings.rs"));