update wasmtime and jni

Author: bluejekyll

Cargo.lock

@@ -14,8 +14,10 @@ crate_type = ["cdylib"]
 anyhow = "1.0.32"
 flexi_logger = "0.16.1"
 #env_logger = "0.7.1"
-jni = "0.17.0"
+jni = "0.19.0"
 log = "0.4.11"
-wasmtime = { version = "0.20", features=["jitdump", "wat", "cache"] }
+wasi-common = "0.26.0"
+wasi-cap-std-sync = "0.26.0"
+wasmtime = { version = "0.26", features=["jitdump", "wat", "cache"] }
 wasmtime-jni-exports = { path = "../wasmtime-jni-exports" }
-wasmtime-wasi = "0.20.0"
+wasmtime-wasi = "0.26.0"

wasmtime-jni/Cargo.toml

@@ -2,7 +2,7 @@ use std::ops::Deref;
 
 use anyhow::{anyhow, ensure, Error};
 use log::debug;
-use wasmtime::{Val, ValType, WeakStore};
+use wasmtime::{Store, Val, ValType};
 pub use wasmtime_jni_exports::WasmSlice;
 
 use crate::ty::{Abi, ComplexTy, ReturnAbi, WasmAlloc, WasmSliceWrapper};
@@ -79,7 +79,7 @@ impl ComplexTy for ByteSlice {
     type Abi = WasmSlice;
 
     #[inline]
-    fn compatible_with_store<'a>(&self, _store: WeakStore<'a>) -> bool {
+    fn compatible_with_store(&self, _store: &Store) -> bool {
         true
     }
 }

wasmtime-jni/src/ty/byte_slice.rs

@@ -1,12 +1,12 @@
 use anyhow::{anyhow, ensure, Error};
-use wasmtime::{Val, ValType, WeakStore};
+use wasmtime::{Store, Val, ValType};
 
 use crate::ty::{WasmAlloc, WasmSliceWrapper};
 
 pub(crate) trait ComplexTy {
     type Abi: Abi;
 
-    fn compatible_with_store<'a>(&self, _store: WeakStore<'a>) -> bool;
+    fn compatible_with_store(&self, _store: &Store) -> bool;
 }
 
 pub(crate) trait Abi: Copy {
@@ -197,7 +197,7 @@ macro_rules! direct_complex_ty {
         impl ComplexTy for $t {
             type Abi = Self;
 
-            fn compatible_with_store<'a>(&self, _store: WeakStore<'a>) -> bool {
+            fn compatible_with_store(&self, _store: &Store) -> bool {
                 true
             }
         }

wasmtime-jni/src/ty/complex_ty.rs

@@ -12,12 +12,12 @@ impl<'j> WasmTy for WasmJString<'j> {
     type Abi = WasmSlice;
 
     #[inline]
-    fn compatible_with_store<'a>(&self, _store: WeakStore<'a>) -> bool {
+    fn compatible_with_store(&self, _store: &Store) -> bool {
         true
     }
 
     #[inline]
-    fn into_abi<'a>(self, store: WeakStore<'a>) -> Self::Abi {
+    fn into_abi(self, store: &Store) -> Self::Abi {
         let jstr = self
             .env
             .get_string(&self.string)
@@ -33,7 +33,7 @@ impl<'j> WasmTy for WasmJString<'j> {
     }
 
     #[inline]
-    unsafe fn from_abi<'a>(abi: Self::Abi, _store: WeakStore<'a>) -> Self {
+    unsafe fn from_abi<'a>(abi: Self::Abi, _store: &Store) -> Self {
         unimplemented!();
     }
 

wasmtime-jni/src/ty/str.rs

@@ -75,8 +75,7 @@ pub extern "system" fn Java_net_bluejekyll_wasmtime_WasmFunction_createFunc<'j>(
             None
         };
 
-        let wasm_ret: Box<[ValType]> =
-            wasm_ret.map_or_else(|| Box::new([]) as Box<_>, |v| Box::new([v]) as Box<_>);
+        let wasm_ret: Vec<ValType> = wasm_ret.map_or_else(|| vec![], |v| vec![v]);
 
         let func = move |caller: Caller, inputs: &[Val], outputs: &mut [Val]| -> Result<(), Trap> {
             let java_args = &java_args;
@@ -235,22 +234,15 @@ pub extern "system" fn Java_net_bluejekyll_wasmtime_WasmFunction_createFunc<'j>(
                     let len = env
                         .get_array_length(jarray)
                         .context("failed to get Java array length")?;
-                    let (jbytes, _is_copy) = env
-                        .get_byte_array_elements(jarray)
+                    let jbytes = env
+                        .get_byte_array_elements(jarray, ReleaseMode::NoCopyBack)
                         .context("failed to get java array elements")?;
-                    let byte_array: &[u8] =
-                        unsafe { slice::from_raw_parts(jbytes as *const u8, len as usize) };
+                    let byte_array: &[u8] = unsafe {
+                        slice::from_raw_parts(jbytes.as_ptr() as *const u8, len as usize)
+                    };
 
                     let bytes = wasm_alloc.alloc_bytes(byte_array)?;
 
-                    // release the array reference, CopyBack is following the JNI guidelines
-                    env.release_byte_array_elements(
-                        jarray,
-                        unsafe { &mut *jbytes },
-                        ReleaseMode::CopyBack,
-                    )
-                    .context("failed to release Java array elements")?;
-
                     // get mutable reference to the return by ref pointer and then store
                     unsafe {
                         let ret_by_ref_loc = wasm_alloc.obj_as_mut::<WasmSlice>(ptr);
@@ -311,11 +303,7 @@ pub extern "system" fn Java_net_bluejekyll_wasmtime_WasmFunction_createFunc<'j>(
             Ok(())
         };
 
-        let func = Func::new(
-            &store,
-            FuncType::new(wasm_args.into_boxed_slice(), wasm_ret),
-            func,
-        );
+        let func = Func::new(&store, FuncType::new(wasm_args, wasm_ret), func);
 
         Ok(OpaquePtr::from(func).make_opaque())
     })

wasmtime-jni/src/wasm_function.rs

@@ -4,7 +4,7 @@ use jni::objects::{JClass, JString};
 use jni::sys::jlong;
 use jni::JNIEnv;
 use wasmtime::{Func, Linker, Module};
-use wasmtime_wasi::{Wasi, WasiCtx};
+use wasmtime_wasi::Wasi;
 
 use crate::opaque_ptr::OpaquePtr;
 use crate::wasm_exception;
@@ -70,7 +70,11 @@ pub extern "system" fn Java_net_bluejekyll_wasmtime_WasmLinker_instantiateNtv<'j
 ) -> jlong {
     wasm_exception::attempt(&env, |_env| {
         let store = linker.store();
-        let wasi = Wasi::new(&store, WasiCtx::new(std::env::args())?);
+        let wasi_ctx = wasi_cap_std_sync::WasiCtxBuilder::new()
+            .inherit_env()?
+            .build()?;
+
+        let wasi = Wasi::new(&store, wasi_ctx);
         wasi.add_to_linker(&mut linker)?;
 
         let instance = linker.instantiate(&module)?;

wasmtime-jni/src/wasm_linker.rs

@@ -238,22 +238,15 @@ impl<'j> WasmVal<'j> {
             WasmVal::ByteArray { jarray, .. } => {
                 // This is should be safe, it's copied into while borrowed the WASM context.
                 let len = env.get_array_length(jarray)?;
-                let (jbytes, _is_copy) = env.get_byte_array_elements(jarray)?;
+                let jbytes = env.get_byte_array_elements(jarray, ReleaseMode::NoCopyBack)?;
                 let byte_array: &[u8] =
-                    unsafe { slice::from_raw_parts(jbytes as *const u8, len as usize) };
+                    unsafe { slice::from_raw_parts(jbytes.as_ptr() as *const u8, len as usize) };
 
                 // the module might not have the memory exported
                 let wasm_alloc = wasm_alloc
                     .ok_or_else(|| anyhow!("no memory or allocator supplied from module"))?;
                 let wasm_slice = wasm_alloc.alloc_bytes(byte_array)?;
 
-                // release the array reference, CopyBack is following the JNI guidelines
-                env.release_byte_array_elements(
-                    jarray,
-                    unsafe { &mut *jbytes },
-                    ReleaseMode::CopyBack,
-                )
-                .context("failed to release Java array elements")?;
                 wasm_slice.store_to_args(args);
                 return Ok(Some(wasm_slice));
             }