Added a cleanup step that will mark all the memory as inaccessible and thus force termination of threads

lib/api/src/externals/memory.rs

@@ -119,6 +119,11 @@ impl Memory {
         self.0.grow(store, delta)
     }
 
+    /// Makes all the memory inaccessible to any reads or writes
+    pub fn make_inaccessible(&self, store: &impl AsStoreRef) -> Result<(), MemoryError> {
+        self.0.make_inaccessible(store)
+    }
+
     /// Copies the memory to a new store and returns a memory reference to it
     pub fn copy_to_store(
         &self,

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

@@ -179,6 +179,11 @@ impl Memory {
     pub fn duplicate(&mut self, _store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
         self.handle.duplicate()
     }
+
+    #[allow(unused)]
+    pub fn make_inaccessible(&self, store: &impl AsStoreRef) -> Result<(), MemoryError> {
+        Err(MemoryError::NotImplemented)
+    }
 }
 
 impl std::cmp::PartialEq for Memory {

lib/api/src/sys/externals/memory.rs

@@ -56,6 +56,13 @@ impl Memory {
         self.handle.get_mut(store.objects_mut()).grow(delta.into())
     }
 
+    /// Makes all the memory inaccessible to any reads or writes
+    pub fn make_inaccessible(&self, store: &impl AsStoreRef) -> Result<(), MemoryError> {
+        self.handle
+            .get(store.as_store_ref().objects())
+            .make_inaccessible()
+    }
+
     pub fn copy_to_store(
         &self,
         store: &impl AsStoreRef,

lib/api/src/sys/tunables.rs

@@ -133,6 +133,7 @@ mod tests {
                 mem,
             }))
         }
+
         /*
         // this code allow custom memory to be ignoring init_memory
         use wasmer_vm::Trap;

lib/sys-utils/src/memory/fd_memory/fd_mmap.rs

@@ -180,6 +180,28 @@ impl FdMmap {
             .map_err(|e| e.to_string())
     }
 
+    /// Make the entire memory inaccessible to both reads and writes.
+    pub fn make_all_inaccessible(&self) -> Result<(), String> {
+        self.make_inaccessible(0, self.len)
+    }
+
+    /// Make the memory starting at `start` and extending for `len` bytes inaccessible
+    /// to both reads and writes.
+    /// `start` and `len` must be native page-size multiples and describe a range within
+    /// `self`'s reserved memory.
+    pub fn make_inaccessible(&self, start: usize, len: usize) -> Result<(), String> {
+        let page_size = region::page::size();
+        assert_eq!(start & (page_size - 1), 0);
+        assert_eq!(len & (page_size - 1), 0);
+        assert!(len <= self.len);
+        assert!(start <= self.len - len);
+
+        // Commit the accessible size.
+        let ptr = self.ptr as *const u8;
+        unsafe { region::protect(ptr.add(start), len, region::Protection::NONE) }
+            .map_err(|e| e.to_string())
+    }
+
     /// Return the allocated memory as a slice of u8.
     pub fn as_slice(&self) -> &[u8] {
         unsafe { slice::from_raw_parts(self.ptr as *const u8, self.len) }

lib/sys-utils/src/memory/fd_memory/memories.rs

@@ -149,6 +149,13 @@ impl WasmMmap {
             size: self.size,
         })
     }
+
+    /// Makes all the memory inaccessible to reads and writes
+    pub fn make_inaccessible(&self) -> Result<(), MemoryError> {
+        self.alloc
+            .make_all_inaccessible()
+            .map_err(MemoryError::Region)
+    }
 }
 
 /// A linear memory instance.
@@ -307,6 +314,11 @@ impl VMOwnedMemory {
             config: self.config.clone(),
         })
     }
+
+    /// Makes all the memory inaccessible to reads and writes
+    fn make_inaccessible(&self) -> Result<(), MemoryError> {
+        self.mmap.make_inaccessible()
+    }
 }
 
 impl LinearMemory for VMOwnedMemory {
@@ -349,6 +361,11 @@ impl LinearMemory for VMOwnedMemory {
         let forked = Self::duplicate(self)?;
         Ok(Box::new(forked))
     }
+
+    /// Makes all the memory inaccessible to reads and writes
+    fn make_inaccessible(&self) -> Result<(), MemoryError> {
+        Self::make_inaccessible(self)
+    }
 }
 
 /// A shared linear memory instance.
@@ -395,6 +412,12 @@ impl VMSharedMemory {
             config: self.config.clone(),
         })
     }
+
+    /// Makes all the memory inaccessible to reads and writes
+    pub fn make_inaccessible(&self) -> Result<(), MemoryError> {
+        let guard = self.mmap.write().unwrap();
+        guard.make_inaccessible()
+    }
 }
 
 impl LinearMemory for VMSharedMemory {
@@ -443,6 +466,11 @@ impl LinearMemory for VMSharedMemory {
         let forked = Self::duplicate(self)?;
         Ok(Box::new(forked))
     }
+
+    /// Makes all the memory inaccessible to reads and writes
+    fn make_inaccessible(&self) -> Result<(), MemoryError> {
+        Self::make_inaccessible(self)
+    }
 }
 
 impl From<VMOwnedMemory> for VMMemory {
@@ -510,6 +538,11 @@ impl LinearMemory for VMMemory {
     fn duplicate(&mut self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
         self.0.duplicate()
     }
+
+    /// Makes all the memory inaccessible to reads and writes
+    fn make_inaccessible(&self) -> Result<(), MemoryError> {
+        self.0.make_inaccessible()
+    }
 }
 
 impl VMMemory {

lib/types/src/error.rs

@@ -85,6 +85,9 @@ pub enum MemoryError {
     /// A user defined error value, used for error cases not listed above.
     #[error("A user-defined error occurred: {0}")]
     Generic(String),
+    /// Not implemented
+    #[error("This operation is not yet implemented")]
+    NotImplemented,
 }
 
 /// An ImportError.

lib/vm/src/memory.rs

@@ -140,6 +140,13 @@ impl WasmMmap {
             size: self.size,
         })
     }
+
+    /// Makes all the memory inaccessible to reads and writes
+    pub fn make_inaccessible(&self) -> Result<(), MemoryError> {
+        self.alloc
+            .make_all_inaccessible()
+            .map_err(MemoryError::Region)
+    }
 }
 
 /// A linear memory instance.
@@ -299,6 +306,11 @@ impl VMOwnedMemory {
             config: self.config.clone(),
         })
     }
+
+    /// Makes all the memory inaccessible to reads and writes
+    pub fn make_inaccessible(&self) -> Result<(), MemoryError> {
+        self.mmap.make_inaccessible()
+    }
 }
 
 impl LinearMemory for VMOwnedMemory {
@@ -341,6 +353,11 @@ impl LinearMemory for VMOwnedMemory {
         let forked = Self::duplicate(self)?;
         Ok(Box::new(forked))
     }
+
+    /// Makes all the memory inaccessible to reads and writes
+    fn make_inaccessible(&self) -> Result<(), MemoryError> {
+        Self::make_inaccessible(self)
+    }
 }
 
 /// A shared linear memory instance.
@@ -390,6 +407,12 @@ impl VMSharedMemory {
             conditions: ThreadConditions::new(),
         })
     }
+
+    /// Makes all the memory inaccessible to reads and writes
+    pub fn make_inaccessible(&self) -> Result<(), MemoryError> {
+        let guard = self.mmap.write().unwrap();
+        guard.make_inaccessible()
+    }
 }
 
 impl LinearMemory for VMSharedMemory {
@@ -452,6 +475,11 @@ impl LinearMemory for VMSharedMemory {
     fn do_notify(&mut self, dst: NotifyLocation, count: u32) -> u32 {
         self.conditions.do_notify(dst, count)
     }
+
+    /// Makes all the memory inaccessible to reads and writes
+    fn make_inaccessible(&self) -> Result<(), MemoryError> {
+        Self::make_inaccessible(self)
+    }
 }
 
 impl From<VMOwnedMemory> for VMMemory {
@@ -533,6 +561,11 @@ impl LinearMemory for VMMemory {
     fn do_notify(&mut self, dst: NotifyLocation, count: u32) -> u32 {
         self.0.do_notify(dst, count)
     }
+
+    /// Makes all the memory inaccessible to reads and writes
+    fn make_inaccessible(&self) -> Result<(), MemoryError> {
+        self.0.make_inaccessible()
+    }
 }
 
 impl VMMemory {
@@ -596,6 +629,11 @@ impl VMMemory {
     pub fn duplicate(&mut self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
         LinearMemory::duplicate(self)
     }
+
+    /// Makes all the memory inaccessible to reads and writes
+    pub fn make_inaccessible(&self) -> Result<(), MemoryError> {
+        LinearMemory::make_inaccessible(self)
+    }
 }
 
 #[doc(hidden)]
@@ -666,4 +704,9 @@ where
     fn do_notify(&mut self, _dst: NotifyLocation, _count: u32) -> u32 {
         0
     }
+
+    /// Makes all the memory inaccessible to reads and writes
+    fn make_inaccessible(&self) -> Result<(), MemoryError> {
+        Err(MemoryError::NotImplemented)
+    }
 }

lib/vm/src/mmap.rs

@@ -233,6 +233,28 @@ impl Mmap {
         Ok(())
     }
 
+    /// Make the entire memory inaccessible to both reads and writes.
+    pub fn make_all_inaccessible(&self) -> Result<(), String> {
+        self.make_inaccessible(0, self.total_size)
+    }
+
+    /// Make the memory starting at `start` and extending for `len` bytes inaccessible
+    /// to both reads and writes.
+    /// `start` and `len` must be native page-size multiples and describe a range within
+    /// `self`'s reserved memory.
+    pub fn make_inaccessible(&self, start: usize, len: usize) -> Result<(), String> {
+        let page_size = region::page::size();
+        assert_eq!(start & (page_size - 1), 0);
+        assert_eq!(len & (page_size - 1), 0);
+        assert_le!(len, self.total_size);
+        assert_le!(start, self.total_size - len);
+
+        // Commit the accessible size.
+        let ptr = self.ptr as *const u8;
+        unsafe { region::protect(ptr.add(start), len, region::Protection::NONE) }
+            .map_err(|e| e.to_string())
+    }
+
     /// Return the allocated memory as a slice of u8.
     pub fn as_slice(&self) -> &[u8] {
         unsafe { slice::from_raw_parts(self.ptr as *const u8, self.total_size) }

lib/wasi/src/bin_factory/exec.rs

@@ -40,15 +40,15 @@ pub fn spawn_exec(
                 VirtualBusError::CompileError
             });
             if module.is_err() {
-                env.blocking_cleanup(Some(Errno::Noexec.into()));
+                env.blocking_cleanup(&store, Some(Errno::Noexec.into()));
             }
             let module = module?;
             compiled_modules.set_compiled_module(binary.hash().as_str(), compiler, &module);
             module
         }
         (None, None) => {
             error!("package has no entry [{}]", name,);
-            env.blocking_cleanup(Some(Errno::Noexec.into()));
+            env.blocking_cleanup(&store, Some(Errno::Noexec.into()));
             return Err(VirtualBusError::CompileError);
         }
     };
@@ -113,7 +113,7 @@ pub fn spawn_exec_module(
                         error!("wasi[{}]::wasm instantiate error ({})", pid, err);
                         wasi_env
                             .data(&store)
-                            .blocking_cleanup(Some(Errno::Noexec.into()));
+                            .blocking_cleanup(&store, Some(Errno::Noexec.into()));
                         return;
                     }
                 };
@@ -127,7 +127,7 @@ pub fn spawn_exec_module(
                     error!("wasi[{}]::wasi initialize error ({})", pid, err);
                     wasi_env
                         .data(&store)
-                        .blocking_cleanup(Some(Errno::Noexec.into()));
+                        .blocking_cleanup(&store, Some(Errno::Noexec.into()));
                     return;
                 }
 
@@ -137,7 +137,7 @@ pub fn spawn_exec_module(
                         thread.thread.set_status_finished(Err(err.into()));
                         wasi_env
                             .data(&store)
-                            .blocking_cleanup(Some(Errno::Noexec.into()));
+                            .blocking_cleanup(&store, Some(Errno::Noexec.into()));
                         return;
                     }
                 }
@@ -168,7 +168,7 @@ pub fn spawn_exec_module(
                 };
 
                 // Cleanup the environment
-                wasi_env.data(&store).blocking_cleanup(Some(code));
+                wasi_env.data(&store).blocking_cleanup(&store, Some(code));
 
                 debug!("wasi[{pid}]::main() has exited with {code}");
                 thread.thread.set_status_finished(ret.map(|a| a.into()));
@@ -200,7 +200,7 @@ impl BinFactory {
                 .await
                 .ok_or(VirtualBusError::NotFound);
             if binary.is_err() {
-                env.cleanup(Some(Errno::Noent.into())).await;
+                env.cleanup(&store, Some(Errno::Noent.into())).await;
             }
             let binary = binary?;