WASI journal and stateful persistence

lib/cli/Cargo.toml

@@ -160,9 +160,11 @@ default = [
   "wat",
   "wast",
   "compiler",
+  "snapshooter",
   "wasmer-artifact-create",
   "static-artifact-create",
 ]
+snapshooter = ["wasmer-wasix/snapshooter"]
 backend = []
 coredump = ["wasm-coredump-builder"]
 sys = ["compiler", "wasmer-vm"]

lib/cli/src/commands/run/wasi.rs

@@ -1,6 +1,7 @@
 use std::{
     collections::{BTreeSet, HashMap},
     path::{Path, PathBuf},
+    str::FromStr,
     sync::{mpsc::Sender, Arc},
     time::Duration,
 };
@@ -33,6 +34,7 @@ use wasmer_wasix::{
             VirtualTaskManagerExt,
         },
     },
+    snapshot,
     types::__WASI_STDIN_FILENO,
     wasmer_wasix_types::wasi::Errno,
     PluggableRuntime, RewindState, Runtime, WasiEnv, WasiEnvBuilder, WasiError, WasiFunctionEnv,
@@ -105,6 +107,34 @@ pub struct Wasi {
     #[clap(long = "enable-async-threads")]
     pub enable_async_threads: bool,
 
+    /// Specifies the snapshot file that Wasmer will use to store
+    /// the state of the WASM process so that it can be later restored
+    #[cfg(feature = "snapshooter")]
+    #[clap(long = "snapshot-to")]
+    pub snapshot_to: Option<PathBuf>,
+
+    /// Indicates what events will cause a snapshot to be taken
+    /// and written to the snapshot file.
+    ///
+    /// If not specified, the default is to snapshot on idle plus if a
+    /// snapshot period is provided it will also default to periodic snapshots
+    /// as well.
+    #[cfg(feature = "snapshooter")]
+    #[clap(long = "snapshot-on")]
+    pub snapshot_on: Vec<SnapshotTrigger>,
+
+    /// Time in seconds between taking snapshots of the process and dumping
+    /// them to the snapshot file.
+    #[cfg(feature = "snapshooter")]
+    #[clap(long = "snapshot-period")]
+    pub snapshot_period: Option<u64>,
+
+    /// When specified, the runtime will restore a previous snapshot
+    /// using the supplied file.
+    #[cfg(feature = "snapshooter")]
+    #[clap(long = "resume-from")]
+    pub resume_from: Option<PathBuf>,
+
     /// Allow instances to send http requests.
     ///
     /// Access to domains is granted by default.
@@ -116,6 +146,47 @@ pub struct Wasi {
     pub deny_multiple_wasi_versions: bool,
 }
 
+/// Various triggers that will cause the runtime to take snapshot
+/// of the WASM state and store it in the snapshot file.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum SnapshotTrigger {
+    /// Triggered when all the threads in the process goes idle
+    Idle,
+    /// Triggered when a listen syscall is invoked on a socket
+    Listen,
+    /// Triggered when the process reads stdin for the first time
+    Stdin,
+    /// Triggered periodically (default 10 seconds) which can be specified using the `snapshot-period` option
+    Periodic,
+    /// Issued if the user sends an interrupt signal (Ctrl + C).
+    Sigint,
+    /// Alarm clock signal (used for timers)
+    Sigalrm,
+    /// The SIGTSTP signal is sent to a process by its controlling terminal to request it to stop temporarily. It is commonly initiated by the user pressing Ctrl-Z.
+    Sigtstp,
+    /// The SIGSTOP signal instructs the operating system to stop a process for later resumption.
+    Sigstop,
+}
+
+impl FromStr for SnapshotTrigger {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        let s = s.trim().to_lowercase();
+        Ok(match s.as_str() {
+            "idle" => Self::Idle,
+            "listen" => Self::Listen,
+            "stdin" => Self::Stdin,
+            "periodic" => Self::Periodic,
+            "intr" | "sigint" | "ctrlc" | "ctrl-c" => Self::Sigint,
+            "alarm" | "timer" | "sigalrm" => Self::Sigalrm,
+            "sigtstp" | "ctrlz" | "ctrl-z" => Self::Sigtstp,
+            "stop" | "sigstop" => Self::Sigstop,
+            a => return Err(anyhow::format_err!("invalid or unknown trigger ({a})")),
+        })
+    }
+}
+
 pub struct RunProperties {
     pub ctx: WasiFunctionEnv,
     pub path: PathBuf,
@@ -267,6 +338,11 @@ impl Wasi {
             rt.set_networking_implementation(virtual_net::UnsupportedVirtualNetworking::default());
         }
 
+        #[cfg(feature = "snapshooter")]
+        if let Some(path) = &self.resume_from {
+            rt.set_snapshooter(Arc::new(snapshot::LogFileSnapShooter::new_std(path)?));
+        }
+
         if !self.no_tty {
             let tty = Arc::new(SysTty::default());
             tty.reset();

lib/wasix/Cargo.toml

@@ -119,6 +119,7 @@ sys = ["webc/mmap", "time", "virtual-mio/sys"]
 sys-default = ["sys", "logging", "host-fs", "sys-poll", "sys-thread", "host-vnet", "host-threads", "host-reqwest"]
 sys-poll = []
 sys-thread = ["tokio/rt", "tokio/time", "tokio/rt-multi-thread", "rayon"]
+snapshooter = []
 
 # Deprecated. Kept it for compatibility
 compiler = []

lib/wasix/src/lib.rs

@@ -50,6 +50,8 @@ pub mod http;
 mod rewind;
 pub mod runners;
 pub mod runtime;
+#[cfg(feature = "snapshooter")]
+pub mod snapshot;
 mod state;
 mod syscalls;
 mod utils;

lib/wasix/src/os/task/thread.rs

@@ -1,3 +1,4 @@
+use serde::{Deserialize, Serialize};
 use std::{
     collections::HashMap,
     ops::{Deref, DerefMut},
@@ -23,7 +24,7 @@ use super::{
 };
 
 /// Represents the ID of a WASI thread
-#[derive(Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
 pub struct WasiThreadId(u32);
 
 impl WasiThreadId {

lib/wasix/src/runtime/mod.rs

@@ -8,6 +8,7 @@ use self::{
     module_cache::{CacheError, ModuleHash},
     task_manager::InlineWaker,
 };
+use crate::snapshot::UNSUPPORTED_SNAP_SHOOTER;
 
 use std::{
     fmt,
@@ -19,6 +20,8 @@ use futures::future::BoxFuture;
 use virtual_net::{DynVirtualNetworking, VirtualNetworking};
 use wasmer::Module;
 
+#[cfg(feature = "snapshooter")]
+use crate::snapshot::{DynSnapShooter, UnsupportedSnapShooter};
 use crate::{
     http::{DynHttpClient, HttpClient},
     os::TtyBridge,
@@ -90,7 +93,7 @@ where
     }
 
     /// Load a a Webassembly module, trying to use a pre-compiled version if possible.
-    fn load_module<'a>(&'a self, wasm: &'a [u8]) -> BoxFuture<'a, Result<Module, anyhow::Error>> {
+    fn load_module<'a>(&'a self, wasm: &'a [u8]) -> BoxFuture<'a, anyhow::Result<Module>> {
         let engine = self.engine();
         let module_cache = self.module_cache();
 
@@ -105,6 +108,13 @@ where
     fn load_module_sync(&self, wasm: &[u8]) -> Result<Module, anyhow::Error> {
         InlineWaker::block_on(self.load_module(wasm))
     }
+
+    /// The snap shooter takes and restores snapshots of the WASM process at specific
+    /// points in time by reading and writing log entries
+    #[cfg(feature = "snapshooter")]
+    fn snap_shooter<'a>(&'a self) -> &'_ DynSnapShooter {
+        &UNSUPPORTED_SNAP_SHOOTER
+    }
 }
 
 /// Load a a Webassembly module, trying to use a pre-compiled version if possible.
@@ -180,6 +190,9 @@ pub struct PluggableRuntime {
     pub module_cache: Arc<dyn ModuleCache + Send + Sync>,
     #[derivative(Debug = "ignore")]
     pub tty: Option<Arc<dyn TtyBridge + Send + Sync>>,
+    #[cfg(feature = "snapshooter")]
+    #[derivative(Debug = "ignore")]
+    pub snapshooter: Arc<DynSnapShooter>,
 }
 
 impl PluggableRuntime {
@@ -214,6 +227,7 @@ impl PluggableRuntime {
             source: Arc::new(source),
             package_loader: Arc::new(loader),
             module_cache: Arc::new(module_cache::in_memory()),
+            snapshooter: Arc::new(UnsupportedSnapShooter::default()) as Arc<DynSnapShooter>,
         }
     }
 
@@ -263,6 +277,11 @@ impl PluggableRuntime {
         self.http_client = Some(Arc::new(client));
         self
     }
+
+    pub fn set_snapshooter(&mut self, snapshooter: Arc<DynSnapShooter>) -> &mut Self {
+        self.snapshooter = snapshooter;
+        self
+    }
 }
 
 impl Runtime for PluggableRuntime {
@@ -308,4 +327,9 @@ impl Runtime for PluggableRuntime {
     fn module_cache(&self) -> Arc<dyn ModuleCache + Send + Sync> {
         self.module_cache.clone()
     }
+
+    #[cfg(feature = "snapshooter")]
+    fn snap_shooter<'a>(&'a self) -> &DynSnapShooter {
+        self.snapshooter.as_ref()
+    }
 }