WASIX Preparation

.github/workflows/benchmark.yaml

@@ -24,7 +24,7 @@ jobs:
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: 1.63
+          toolchain: 1.64
       - name: Configure cargo data directory
         # After this point, all cargo registry and crate data is stored in
         # $GITHUB_WORKSPACE/.cargo_home. This allows us to cache only the files

.github/workflows/build.yml

@@ -100,7 +100,7 @@ jobs:
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: 1.63
+          toolchain: 1.64
           target: ${{ matrix.target }}
       - uses: Swatinem/rust-cache@v1
         if: matrix.use_sccache != true

.github/workflows/cloudcompiler.yaml

@@ -21,7 +21,7 @@ jobs:
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: 1.63
+          toolchain: 1.64
           target: ${{ matrix.target }}
       - name: Install wasm32-wasi target
         shell: bash

.github/workflows/documentation.yaml

@@ -16,7 +16,7 @@ jobs:
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: 1.63
+          toolchain: 1.64
       - name: Install LLVM
         shell: bash
         run: |

.github/workflows/test.yaml

@@ -104,9 +104,11 @@ jobs:
       - name: make test-js
         run: |
           make test-js
-      - name: make test-js-core
-        run: |
-          make test-js-core
+
+      # The no_std functionality doesn't work at the moment - no point in testing it.
+      # - name: make test-js-core
+      #   run: |
+      #     make test-js-core
 
   test_wasm_build:
     name: Test wasm build

Makefile

@@ -497,8 +497,10 @@ test-examples: test-stage-5-test-examples test-stage-6-test-examples-release
 
 test-js: test-js-api test-js-wasi
 
-test-js-core:
-	cd lib/api && wasm-pack test --node -- --no-default-features --features js,core,wasm-types-polyfill,wat
+# TODO: disabled because the no-std / core feature doesn't actually work at the moment.
+# See https://github.com/wasmerio/wasmer/issues/3429
+# test-js-core:
+# 	cd lib/api && wasm-pack test --node -- --no-default-features --features js,core,wasm-types-polyfill,wat
 
 test-js-api:
 	cd lib/api && wasm-pack test --node -- --no-default-features --features js-default,wat

deny.toml

@@ -49,7 +49,13 @@ notice = "warn"
 # output a note when they are encountered.
 ignore = [
     #"RUSTSEC-0000-0000",
+
 ]
+# If this is true, then cargo deny will use the git executable to fetch advisory database.
+# If this is false, then it uses a built-in git library.
+# Setting this to true can be helpful if you have special authentication requirements that cargo-deny does not support.
+# See Git Authentication for more information about setting up git authentication.
+git-fetch-with-cli = true
 # Threshold for security vulnerabilities, any vulnerability with a CVSS score
 # lower than the range specified will be ignored. Note that ignored advisories
 # will still output a note when they are encountered.
@@ -105,13 +111,21 @@ confidence-threshold = 0.8
 exceptions = [
     # Each entry is the crate and version constraint, and its specific allow
     # list
-    { allow = ["LicenseRef-LICENSE.txt"], name = "webc", version = "*" },
 ]
 
+
+
 # Some crates don't have (easily) machine readable licensing information,
 # adding a clarification entry for it allows you to manually specify the
 # licensing information
-#[[licenses.clarify]]
+[[licenses.clarify]]
+name = "webc"
+version = "*"
+expression = "BSL-1.0"
+license-files = [
+  { path = "LICENSE.txt", hash = 0xa2180a97 }
+]
+
 # The name of the crate the clarification applies to
 #name = "ring"
 # The optional version constraint for the crate

lib/api/Cargo.toml

@@ -26,6 +26,7 @@ indexmap = { version = "1.6" }
 cfg-if = "1.0"
 thiserror = "1.0"
 more-asserts = "0.2"
+derivative = { version = "^2" }
 bytes = "1"
 # - Optional shared dependencies.
 wat = { version = "1.0", optional = true }
@@ -117,7 +118,7 @@ jit = ["engine"]
 js = ["wasm-bindgen", "js-sys"]
 js-default = ["js", "std", "wasm-types-polyfill"]
 
-wasm-types-polyfill = ["js", "wasmparser"]
+wasm-types-polyfill = ["js", "wasmparser", "js-serializable-module" ]
 
 js-serializable-module = []
 

lib/api/src/into_bytes.rs

@@ -0,0 +1,50 @@
+use bytes::Bytes;
+use std::borrow::Cow;
+
+/// Convert binary data into [`bytes::Bytes`].
+pub trait IntoBytes {
+    /// Convert binary data into [`bytes::Bytes`].
+    fn into_bytes(self) -> Bytes;
+}
+
+impl IntoBytes for Bytes {
+    fn into_bytes(self) -> Bytes {
+        self
+    }
+}
+
+impl IntoBytes for Vec<u8> {
+    fn into_bytes(self) -> Bytes {
+        Bytes::from(self)
+    }
+}
+
+impl IntoBytes for &Vec<u8> {
+    fn into_bytes(self) -> Bytes {
+        Bytes::from(self.clone())
+    }
+}
+
+impl IntoBytes for &[u8] {
+    fn into_bytes(self) -> Bytes {
+        Bytes::from(self.to_vec())
+    }
+}
+
+impl<const N: usize> IntoBytes for &[u8; N] {
+    fn into_bytes(self) -> Bytes {
+        Bytes::from(self.to_vec())
+    }
+}
+
+impl IntoBytes for &str {
+    fn into_bytes(self) -> Bytes {
+        Bytes::from(self.as_bytes().to_vec())
+    }
+}
+
+impl IntoBytes for Cow<'_, [u8]> {
+    fn into_bytes(self) -> Bytes {
+        Bytes::from(self.to_vec())
+    }
+}

lib/api/src/js/export.rs

@@ -1,12 +1,17 @@
 use crate::js::error::WasmError;
 use crate::js::store::{AsStoreMut, AsStoreRef, InternalStoreHandle};
 use crate::js::wasm_bindgen_polyfill::Global;
+use crate::MemoryView;
 use js_sys::Function;
 use js_sys::WebAssembly::{Memory, Table};
 use serde::{Deserialize, Serialize};
 use std::fmt;
+#[cfg(feature = "tracing")]
+use tracing::trace;
 use wasm_bindgen::{JsCast, JsValue};
-use wasmer_types::{ExternType, FunctionType, GlobalType, MemoryType, TableType, WASM_PAGE_SIZE};
+use wasmer_types::{
+    ExternType, FunctionType, GlobalType, MemoryError, MemoryType, Pages, TableType, WASM_PAGE_SIZE,
+};
 
 /// Represents linear memory that is managed by the javascript runtime
 #[derive(Clone, Debug, PartialEq)]
@@ -25,7 +30,8 @@ struct DummyBuffer {
 }
 
 impl VMMemory {
-    pub(crate) fn new(memory: Memory, ty: MemoryType) -> Self {
+    /// Creates a new memory directly from a WebAssembly javascript object
+    pub fn new(memory: Memory, ty: MemoryType) -> Self {
         Self { memory, ty }
     }
 
@@ -45,6 +51,52 @@ impl VMMemory {
     pub(crate) fn try_clone(&self) -> Option<VMMemory> {
         Some(self.clone())
     }
+
+    /// Copies this memory to a new memory
+    pub fn duplicate(&self) -> Result<VMMemory, wasmer_types::MemoryError> {
+        let new_memory = crate::Memory::new_internal(self.ty.clone())?;
+
+        #[cfg(feature = "tracing")]
+        trace!("memory copy started");
+
+        let src = MemoryView::new_raw(&self.memory);
+        let amount = src.data_size() as usize;
+        let mut dst = MemoryView::new_raw(&new_memory);
+        let dst_size = dst.data_size() as usize;
+
+        if amount > dst_size {
+            let delta = amount - dst_size;
+            let pages = ((delta - 1) / WASM_PAGE_SIZE) + 1;
+
+            let our_js_memory: &crate::js::externals::memory::JSMemory =
+                JsCast::unchecked_from_js_ref(&new_memory);
+            our_js_memory.grow(pages as u32).map_err(|err| {
+                if err.is_instance_of::<js_sys::RangeError>() {
+                    let cur_pages = dst_size;
+                    MemoryError::CouldNotGrow {
+                        current: Pages(cur_pages as u32),
+                        attempted_delta: Pages(pages as u32),
+                    }
+                } else {
+                    MemoryError::Generic(err.as_string().unwrap())
+                }
+            })?;
+
+            dst = MemoryView::new_raw(&new_memory);
+        }
+
+        src.copy_to_memory(amount as u64, &dst).map_err(|err| {
+            wasmer_types::MemoryError::Generic(format!("failed to copy the memory - {}", err))
+        })?;
+
+        #[cfg(feature = "tracing")]
+        trace!("memory copy finished (size={})", dst.size().bytes().0);
+
+        Ok(Self {
+            memory: new_memory,
+            ty: self.ty.clone(),
+        })
+    }
 }
 
 #[derive(Clone, Debug, PartialEq)]

lib/api/src/js/externals/function.rs

@@ -61,6 +61,12 @@ pub struct Function {
     pub(crate) handle: StoreHandle<VMFunction>,
 }
 
+impl From<StoreHandle<VMFunction>> for Function {
+    fn from(handle: StoreHandle<VMFunction>) -> Self {
+        Self { handle }
+    }
+}
+
 impl Function {
     /// Creates a new host `Function` (dynamic) with the provided signature.
     ///
@@ -393,6 +399,13 @@ impl Function {
         store: &mut impl AsStoreMut,
         params: &[Value],
     ) -> Result<Box<[Value]>, RuntimeError> {
+        #[allow(unused_unsafe)]
+        let params: Vec<_> = unsafe {
+            params
+                .iter()
+                .map(|a| a.as_raw_value(&store.as_store_ref()))
+                .collect()
+        };
         let arr = js_sys::Array::new_with_length(params.len() as u32);
 
         // let raw_env = env.as_raw() as *mut u8;
@@ -402,11 +415,34 @@ impl Function {
             let js_value = param.as_jsvalue(&store.as_store_ref());
             arr.set(i as u32, js_value);
         }
-        let result = js_sys::Reflect::apply(
-            &self.handle.get(store.as_store_ref().objects()).function,
-            &wasm_bindgen::JsValue::NULL,
-            &arr,
-        )?;
+
+        let result = {
+            let mut r;
+            loop {
+                r = js_sys::Reflect::apply(
+                    &self.handle.get(store.as_store_ref().objects()).function,
+                    &wasm_bindgen::JsValue::NULL,
+                    &arr,
+                );
+                let store_mut = store.as_store_mut();
+                if let Some(callback) = store_mut.inner.on_called.take() {
+                    match callback(store_mut) {
+                        Ok(wasmer_types::OnCalledAction::InvokeAgain) => {
+                            continue;
+                        }
+                        Ok(wasmer_types::OnCalledAction::Finish) => {
+                            break;
+                        }
+                        Ok(wasmer_types::OnCalledAction::Trap(trap)) => {
+                            return Err(RuntimeError::user(trap))
+                        }
+                        Err(trap) => return Err(RuntimeError::user(trap)),
+                    }
+                }
+                break;
+            }
+            r?
+        };
 
         let result_types = self.handle.get(store.as_store_ref().objects()).ty.results();
         match result_types.len() {
@@ -1134,16 +1170,18 @@ mod inner {
                         T: Send + 'static,
                         Func: Fn(FunctionEnvMut<'_, T>, $( $x , )*) -> RetsAsResult + 'static,
                     {
-                        // let env: &Env = unsafe { &*(ptr as *const u8 as *const Env) };
-                        let func: &Func = &*(&() as *const () as *const Func);
                         let mut store = StoreMut::from_raw(store_ptr as *mut _);
                         let mut store2 = StoreMut::from_raw(store_ptr as *mut _);
 
-                        let result = panic::catch_unwind(AssertUnwindSafe(|| {
-                            let handle: StoreHandle<VMFunctionEnvironment> = StoreHandle::from_internal(store2.objects_mut().id(), InternalStoreHandle::from_index(handle_index).unwrap());
-                            let env: FunctionEnvMut<T> = FunctionEnv::from_handle(handle).into_mut(&mut store2);
-                            func(env, $( FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x)) ),* ).into_result()
-                        }));
+                        let result = {
+                            // let env: &Env = unsafe { &*(ptr as *const u8 as *const Env) };
+                            let func: &Func = &*(&() as *const () as *const Func);
+                            panic::catch_unwind(AssertUnwindSafe(|| {
+                                let handle: StoreHandle<VMFunctionEnvironment> = StoreHandle::from_internal(store2.objects_mut().id(), InternalStoreHandle::from_index(handle_index).unwrap());
+                                let env: FunctionEnvMut<T> = FunctionEnv::from_handle(handle).into_mut(&mut store2);
+                                func(env, $( FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x)) ),* ).into_result()
+                            }))
+                        };
 
                         match result {
                             Ok(Ok(result)) => return result.into_c_struct(&mut store),