wasmtime 16.0.0 → 17.0.1

data/ext/src/helpers/mod.rs

@@ -1,6 +1,10 @@
 mod macros;
+mod nogvl;
 mod static_id;
 mod symbol_enum;
+mod tmplock;
 
+pub use nogvl::nogvl;
 pub use static_id::StaticId;
 pub use symbol_enum::SymbolEnum;
+pub use tmplock::Tmplock;

data/ext/src/helpers/nogvl.rs

@@ -0,0 +1,29 @@
+use std::{ffi::c_void, mem::MaybeUninit, ptr::null_mut};
+
+use rb_sys::rb_thread_call_without_gvl;
+
+unsafe extern "C" fn call_without_gvl<F, R>(arg: *mut c_void) -> *mut c_void
+where
+    F: FnMut() -> R,
+    R: Sized,
+{
+    let arg = arg as *mut (&mut F, &mut MaybeUninit<R>);
+    let (func, result) = unsafe { &mut *arg };
+    result.write(func());
+
+    null_mut()
+}
+
+pub fn nogvl<F, R>(mut func: F) -> R
+where
+    F: FnMut() -> R,
+    R: Sized,
+{
+    let result = MaybeUninit::uninit();
+    let arg_ptr = &(&mut func, &result) as *const _ as *mut c_void;
+
+    unsafe {
+        rb_thread_call_without_gvl(Some(call_without_gvl::<F, R>), arg_ptr, None, null_mut());
+        result.assume_init()
+    }
+}

data/ext/src/helpers/tmplock.rs

@@ -0,0 +1,45 @@
+use magnus::{
+    rb_sys::{protect, AsRawValue},
+    RString,
+};
+
+pub trait Tmplock {
+    fn as_locked_slice(&self) -> Result<(&[u8], TmplockGuard), magnus::Error>;
+    fn as_locked_str(&self) -> Result<(&str, TmplockGuard), magnus::Error>;
+}
+
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct TmplockGuard {
+    raw: rb_sys::VALUE,
+}
+
+impl Drop for TmplockGuard {
+    fn drop(&mut self) {
+        let result = unsafe { protect(|| rb_sys::rb_str_unlocktmp(self.raw)) };
+        debug_assert!(
+            result.is_ok(),
+            "failed to unlock tmplock for unknown reason"
+        );
+    }
+}
+
+impl Tmplock for RString {
+    fn as_locked_slice(&self) -> Result<(&[u8], TmplockGuard), magnus::Error> {
+        let raw = self.as_raw();
+        let slice = unsafe { self.as_slice() };
+        let raw = protect(|| unsafe { rb_sys::rb_str_locktmp(raw) })?;
+        let guard = TmplockGuard { raw };
+
+        Ok((slice, guard))
+    }
+
+    fn as_locked_str(&self) -> Result<(&str, TmplockGuard), magnus::Error> {
+        let str_result = unsafe { self.as_str()? };
+        let raw = self.as_raw();
+        let raw = protect(|| unsafe { rb_sys::rb_str_locktmp(raw) })?;
+        let guard = TmplockGuard { raw };
+
+        Ok((str_result, guard))
+    }
+}

data/ext/src/ruby_api/engine.rs

@@ -2,7 +2,10 @@ use super::{
     config::{default_config, hash_to_config},
     root,
 };
-use crate::error;
+use crate::{
+    error,
+    helpers::{nogvl, Tmplock},
+};
 use magnus::{
     class, function, method, prelude::*, scan_args, typed_data::Obj, value::LazyId, Error, Module,
     Object, RHash, RString, Ruby, TryConvert, Value,
@@ -168,8 +171,9 @@ impl Engine {
     /// @return [String] Binary String of the compiled module.
     /// @see Module.deserialize
     pub fn precompile_module(&self, wat_or_wasm: RString) -> Result<RString, Error> {
-        self.inner
-            .precompile_module(unsafe { wat_or_wasm.as_slice() })
+        let (wat_or_wasm, _guard) = wat_or_wasm.as_locked_slice()?;
+
+        nogvl(|| self.inner.precompile_module(wat_or_wasm))
             .map(|bytes| RString::from_slice(&bytes))
             .map_err(|e| error!("{}", e.to_string()))
     }

data/ext/src/ruby_api/mod.rs

@@ -25,6 +25,7 @@ mod params;
 mod store;
 mod table;
 mod trap;
+mod wasi_ctx;
 mod wasi_ctx_builder;
 
 pub use caller::Caller;
@@ -37,6 +38,7 @@ pub use module::Module;
 pub use params::Params;
 pub use store::Store;
 pub use trap::Trap;
+pub use wasi_ctx::WasiCtx;
 pub use wasi_ctx_builder::WasiCtxBuilder;
 
 /// The "Wasmtime" Ruby module.
@@ -83,6 +85,7 @@ pub fn init(ruby: &Ruby) -> Result<(), Error> {
     wasi_ctx_builder::init()?;
     table::init()?;
     global::init()?;
+    wasi_ctx::init()?;
 
     Ok(())
 }

data/ext/src/ruby_api/module.rs

@@ -1,7 +1,18 @@
+use std::{
+    mem::{transmute, MaybeUninit},
+    ops::Deref,
+    os::raw::c_void,
+};
+
 use super::{engine::Engine, root};
-use crate::error;
-use magnus::{class, function, method, Error, Module as _, Object, RString};
-use rb_sys::tracking_allocator::ManuallyTracked;
+use crate::{
+    error,
+    helpers::{nogvl, Tmplock},
+};
+use magnus::{class, function, method, rb_sys::AsRawValue, Error, Module as _, Object, RString};
+use rb_sys::{
+    rb_str_locktmp, rb_str_unlocktmp, tracking_allocator::ManuallyTracked, RSTRING_LEN, RSTRING_PTR,
+};
 use wasmtime::Module as ModuleImpl;
 
 /// @yard
@@ -25,8 +36,8 @@ impl Module {
     /// @return [Wasmtime::Module]
     pub fn new(engine: &Engine, wat_or_wasm: RString) -> Result<Self, Error> {
         let eng = engine.get();
-        // SAFETY: this string is immediately copied and never moved off the stack
-        let module = ModuleImpl::new(eng, unsafe { wat_or_wasm.as_slice() })
+        let (locked_slice, _locked_slice_guard) = wat_or_wasm.as_locked_slice()?;
+        let module = nogvl(|| ModuleImpl::new(eng, locked_slice))
             .map_err(|e| error!("Could not build module: {}", e))?;
 
         Ok(module.into())
@@ -39,8 +50,9 @@ impl Module {
     /// @return [Wasmtime::Module]
     pub fn from_file(engine: &Engine, path: RString) -> Result<Self, Error> {
         let eng = engine.get();
+        let (path, _locked_str_guard) = path.as_locked_str()?;
         // SAFETY: this string is immediately copied and never moved off the stack
-        let module = ModuleImpl::from_file(eng, unsafe { path.as_str()? })
+        let module = nogvl(|| ModuleImpl::from_file(eng, path))
             .map_err(|e| error!("Could not build module from file: {}", e))?;
 
         Ok(module.into())
@@ -83,8 +95,10 @@ impl Module {
     /// @return [String]
     /// @see .deserialize
     pub fn serialize(&self) -> Result<RString, Error> {
-        self.get()
-            .serialize()
+        let module = self.get();
+        let bytes = module.serialize();
+
+        bytes
             .map(|bytes| RString::from_slice(&bytes))
             .map_err(|e| error!("{:?}", e))
     }

data/ext/src/ruby_api/store.rs

@@ -1,7 +1,7 @@
 use super::errors::wasi_exit_error;
-use super::{caller::Caller, engine::Engine, root, trap::Trap, wasi_ctx_builder::WasiCtxBuilder};
+use super::{caller::Caller, engine::Engine, root, trap::Trap, wasi_ctx::WasiCtx};
 use crate::{define_rb_intern, error};
-use magnus::Class;
+use magnus::value::StaticSymbol;
 use magnus::{
     class, function,
     gc::{Compactor, Marker},
@@ -10,20 +10,27 @@ use magnus::{
     value::Opaque,
     DataTypeFunctions, Error, IntoValue, Module, Object, Ruby, TypedData, Value,
 };
+use magnus::{Class, RHash};
+use std::borrow::Borrow;
 use std::cell::UnsafeCell;
 use std::convert::TryFrom;
-use wasmtime::{AsContext, AsContextMut, Store as StoreImpl, StoreContext, StoreContextMut};
-use wasmtime_wasi::{I32Exit, WasiCtx};
+use wasmtime::{
+    AsContext, AsContextMut, Store as StoreImpl, StoreContext, StoreContextMut, StoreLimits,
+    StoreLimitsBuilder,
+};
+use wasmtime_wasi::{I32Exit, WasiCtx as WasiCtxImpl};
 
 define_rb_intern!(
     WASI_CTX => "wasi_ctx",
+    LIMITS => "limits",
 );
 
 pub struct StoreData {
     user_data: Value,
-    wasi: Option<WasiCtx>,
+    wasi: Option<WasiCtxImpl>,
     refs: Vec<Value>,
     last_error: Option<Error>,
+    store_limits: StoreLimits,
 }
 
 impl StoreData {
@@ -35,7 +42,7 @@ impl StoreData {
         self.wasi.is_some()
     }
 
-    pub fn wasi_ctx_mut(&mut self) -> &mut WasiCtx {
+    pub fn wasi_ctx_mut(&mut self) -> &mut WasiCtxImpl {
         self.wasi.as_mut().expect("Store must have a WASI context")
     }
 
@@ -106,6 +113,19 @@ impl Store {
     ///   The data attached to the store. Can be retrieved through {Wasmtime::Store#data} and {Wasmtime::Caller#data}.
     /// @param wasi_ctx [Wasmtime::WasiCtxBuilder]
     ///   The WASI context to use in this store.
+    /// @param limits [Hash]
+    ///   See the {https://docs.rs/wasmtime/latest/wasmtime/struct.StoreLimitsBuilder.html +StoreLimitsBuilder+‘s Rust doc}
+    ///   for detailed description of the different options and the defaults.
+    /// @option limits memory_size [Integer]
+    ///   The maximum number of bytes a linear memory can grow to.
+    /// @option limits table_elements [Integer]
+    ///   The maximum number of elements in a table.
+    /// @option limits instances [Integer]
+    ///   The maximum number of instances that can be created for a Store.
+    /// @option limits tables [Integer]
+    ///   The maximum number of tables that can be created for a Store.
+    /// @option limits memories [Integer]
+    ///   The maximum number of linear memories that can be created for a Store.
     /// @return [Wasmtime::Store]
     ///
     /// @example
@@ -113,19 +133,22 @@ impl Store {
     ///
     /// @example
     ///   store = Wasmtime::Store.new(Wasmtime::Engine.new, {})
-    pub fn new(ruby: &Ruby, args: &[Value]) -> Result<Self, Error> {
+    pub fn new(args: &[Value]) -> Result<Self, Error> {
         let args = scan_args::scan_args::<(&Engine,), (Option<Value>,), (), (), _, ()>(args)?;
-        let kw = scan_args::get_kwargs::<_, (), (Option<&WasiCtxBuilder>,), ()>(
+        let kw = scan_args::get_kwargs::<_, (), (Option<&WasiCtx>, Option<RHash>), ()>(
             args.keywords,
             &[],
-            &[*WASI_CTX],
+            &[*WASI_CTX, *LIMITS],
         )?;
+
         let (engine,) = args.required;
         let (user_data,) = args.optional;
         let user_data = user_data.unwrap_or_else(|| ().into_value());
-        let wasi = match kw.optional.0 {
-            None => None,
-            Some(wasi_ctx_builder) => Some(wasi_ctx_builder.build_context(ruby)?),
+        let wasi = kw.optional.0.map(|wasi_ctx| wasi_ctx.get_inner());
+
+        let limiter = match kw.optional.1 {
+            None => StoreLimitsBuilder::new(),
+            Some(limits) => hash_to_store_limits_builder(limits)?,
         };
 
         let eng = engine.get();
@@ -134,11 +157,14 @@ impl Store {
             wasi,
             refs: Default::default(),
             last_error: Default::default(),
+            store_limits: limiter.build(),
         };
         let store = Self {
             inner: UnsafeCell::new(StoreImpl::new(eng, store_data)),
         };
 
+        unsafe { &mut *store.inner.get() }.limiter(|data| &mut data.store_limits);
+
         Ok(store)
     }
 
@@ -298,6 +324,34 @@ impl<'a> StoreContextValue<'a> {
     }
 }
 
+fn hash_to_store_limits_builder(limits: RHash) -> Result<StoreLimitsBuilder, Error> {
+    let mut limiter: StoreLimitsBuilder = StoreLimitsBuilder::new();
+
+    if let Some(memory_size) = limits.lookup::<_, Option<u64>>(StaticSymbol::new("memory_size"))? {
+        limiter = limiter.memory_size(memory_size as usize);
+    }
+
+    if let Some(table_elements) =
+        limits.lookup::<_, Option<u64>>(StaticSymbol::new("table_elements"))?
+    {
+        limiter = limiter.table_elements(table_elements as u32);
+    }
+
+    if let Some(instances) = limits.lookup::<_, Option<u64>>(StaticSymbol::new("instances"))? {
+        limiter = limiter.instances(instances as usize);
+    }
+
+    if let Some(tables) = limits.lookup::<_, Option<u64>>(StaticSymbol::new("tables"))? {
+        limiter = limiter.tables(tables as usize);
+    }
+
+    if let Some(memories) = limits.lookup::<_, Option<u64>>(StaticSymbol::new("memories"))? {
+        limiter = limiter.memories(memories as usize);
+    }
+
+    Ok(limiter)
+}
+
 pub fn init() -> Result<(), Error> {
     let class = root().define_class("Store", class::object())?;
 

data/ext/src/ruby_api/wasi_ctx.rs

@@ -0,0 +1,110 @@
+use super::{
+    root,
+    wasi_ctx_builder::{file_r, file_w, wasi_file},
+    WasiCtxBuilder,
+};
+use crate::error;
+use deterministic_wasi_ctx::build_wasi_ctx as wasi_deterministic_ctx;
+use magnus::{
+    class, function, gc::Marker, method, prelude::*, typed_data::Obj, Error, Object, RString,
+    RTypedData, Ruby, TypedData, Value,
+};
+use std::{borrow::Borrow, cell::RefCell, fs::File, path::PathBuf};
+use wasi_common::pipe::ReadPipe;
+use wasmtime_wasi::WasiCtx as WasiCtxImpl;
+
+/// @yard
+/// WASI context to be sent as {Store#new}’s +wasi_ctx+ keyword argument.
+///
+/// Instance methods mutate the current object and return +self+.
+///
+/// @see https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/struct.WasiCtx.html
+///   Wasmtime's Rust doc
+#[magnus::wrap(class = "Wasmtime::WasiCtx", size, free_immediately)]
+pub struct WasiCtx {
+    inner: RefCell<WasiCtxImpl>,
+}
+
+type RbSelf = Obj<WasiCtx>;
+
+impl WasiCtx {
+    /// @yard
+    /// Create a new deterministic {WasiCtx}. See https://github.com/Shopify/deterministic-wasi-ctx for more details
+    /// @return [WasiCtx]
+    pub fn deterministic() -> Self {
+        Self {
+            inner: RefCell::new(wasi_deterministic_ctx()),
+        }
+    }
+
+    /// @yard
+    /// Set stdin to read from the specified file.
+    /// @param path [String] The path of the file to read from.
+    /// @def set_stdin_file(path)
+    /// @return [WasiCtxBuilder] +self+
+    fn set_stdin_file(rb_self: RbSelf, path: RString) -> RbSelf {
+        let inner = rb_self.inner.borrow_mut();
+        let cs = file_r(path).map(wasi_file).unwrap();
+        inner.set_stdin(cs);
+        rb_self
+    }
+
+    /// @yard
+    /// Set stdin to the specified String.
+    /// @param content [String]
+    /// @def set_stdin_string(content)
+    /// @return [WasiCtx] +self+
+    fn set_stdin_string(rb_self: RbSelf, content: RString) -> RbSelf {
+        let inner = rb_self.inner.borrow_mut();
+        let str = unsafe { content.as_slice() };
+        let pipe = ReadPipe::from(str);
+        inner.set_stdin(Box::new(pipe));
+        rb_self
+    }
+
+    /// @yard
+    /// Set stdout to write to a file. Will truncate the file if it exists,
+    /// otherwise try to create it.
+    /// @param path [String] The path of the file to write to.
+    /// @def set_stdout_file(path)
+    /// @return [WasiCtx] +self+
+    fn set_stdout_file(rb_self: RbSelf, path: RString) -> RbSelf {
+        let inner = rb_self.inner.borrow_mut();
+        let cs = file_w(path).map(wasi_file).unwrap();
+        inner.set_stdout(cs);
+        rb_self
+    }
+
+    /// @yard
+    /// Set stderr to write to a file. Will truncate the file if it exists,
+    /// otherwise try to create it.
+    /// @param path [String] The path of the file to write to.
+    /// @def set_stderr_file(path)
+    /// @return [WasiCtx] +self+
+    fn set_stderr_file(rb_self: RbSelf, path: RString) -> RbSelf {
+        let inner = rb_self.inner.borrow_mut();
+        let cs = file_w(path).map(wasi_file).unwrap();
+        inner.set_stderr(cs);
+        rb_self
+    }
+
+    pub fn from_inner(inner: WasiCtxImpl) -> Self {
+        Self {
+            inner: RefCell::new(inner),
+        }
+    }
+
+    pub fn get_inner(&self) -> WasiCtxImpl {
+        return self.inner.borrow().clone();
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("WasiCtx", class::object())?;
+    class.define_singleton_method("deterministic", function!(WasiCtx::deterministic, 0))?;
+    class.define_method("set_stdin_file", method!(WasiCtx::set_stdin_file, 1))?;
+    class.define_method("set_stdin_string", method!(WasiCtx::set_stdin_string, 1))?;
+    class.define_method("set_stdout_file", method!(WasiCtx::set_stdout_file, 1))?;
+    class.define_method("set_stderr_file", method!(WasiCtx::set_stderr_file, 1))?;
+    Ok(())
+}

data/ext/src/ruby_api/wasi_ctx_builder.rs

@@ -1,4 +1,4 @@
-use super::root;
+use super::{root, WasiCtx};
 use crate::error;
 use magnus::{
     class, function, gc::Marker, method, typed_data::Obj, value::Opaque, DataTypeFunctions, Error,
@@ -192,9 +192,9 @@ impl WasiCtxBuilder {
         rb_self
     }
 
-    pub fn build_context(&self, ruby: &Ruby) -> Result<wasmtime_wasi::WasiCtx, Error> {
+    pub fn build(ruby: &Ruby, rb_self: RbSelf) -> Result<WasiCtx, Error> {
         let mut builder = wasmtime_wasi::WasiCtxBuilder::new();
-        let inner = self.inner.borrow();
+        let inner = rb_self.inner.borrow();
 
         if let Some(stdin) = inner.stdin.as_ref() {
             match stdin {
@@ -243,23 +243,24 @@ impl WasiCtxBuilder {
             builder.envs(&env_vec).map_err(|e| error!("{}", e))?;
         }
 
-        Ok(builder.build())
+        let ctx = WasiCtx::from_inner(builder.build());
+        Ok(ctx)
     }
 }
 
-fn file_r(path: RString) -> Result<File, Error> {
+pub fn file_r(path: RString) -> Result<File, Error> {
     // SAFETY: &str copied before calling in to Ruby, no GC can happen before.
     File::open(PathBuf::from(unsafe { path.as_str()? }))
         .map_err(|e| error!("Failed to open file {}\n{}", path, e))
 }
 
-fn file_w(path: RString) -> Result<File, Error> {
+pub fn file_w(path: RString) -> Result<File, Error> {
     // SAFETY: &str copied before calling in to Ruby, no GC can happen before.
     File::create(unsafe { path.as_str()? })
         .map_err(|e| error!("Failed to write to file {}\n{}", path, e))
 }
 
-fn wasi_file(file: File) -> Box<wasi_cap_std_sync::file::File> {
+pub fn wasi_file(file: File) -> Box<wasi_cap_std_sync::file::File> {
     let file = cap_std::fs::File::from_std(file);
     let file = wasi_cap_std_sync::file::File::from_cap_std(file);
     Box::new(file)
@@ -292,5 +293,7 @@ pub fn init() -> Result<(), Error> {
 
     class.define_method("set_argv", method!(WasiCtxBuilder::set_argv, 1))?;
 
+    class.define_method("build", method!(WasiCtxBuilder::build, 0))?;
+
     Ok(())
 }

data/lib/wasmtime/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wasmtime
-  VERSION = "16.0.0"
+  VERSION = "17.0.1"
 end