Record and Replay Support for Component Model

Cargo.toml

@@ -492,6 +492,14 @@ gc-drc = ["gc", "wasmtime/gc-drc", "wasmtime-cli-flags/gc-drc"]
 gc-null = ["gc", "wasmtime/gc-null", "wasmtime-cli-flags/gc-null"]
 pulley = ["wasmtime-cli-flags/pulley"]
 stack-switching = ["wasmtime/stack-switching", "wasmtime-cli-flags/stack-switching"]
+# `rr` only configures the base infrastructure and is not practically useful by itself
+# Use `rr-component` or `rr-core` for generating record/replay events for components/core wasm
+# respectively
+# Use `rr-validate` for additional validation checks over the above two features
+rr = ["wasmtime-cli-flags/rr"]
+rr-component = ["wasmtime/rr-component", "rr"]
+rr-core = ["wasmtime/rr-core", "rr"]
+rr-validate = ["wasmtime/rr-validate", "wasmtime-cli-flags/rr-validate"]
 
 # CLI subcommands for the `wasmtime` executable. See `wasmtime $cmd --help`
 # for more information on each subcommand.

crates/cli-flags/Cargo.toml

@@ -40,3 +40,5 @@ threads = ["wasmtime/threads"]
 memory-protection-keys = ["wasmtime/memory-protection-keys"]
 pulley = ["wasmtime/pulley"]
 stack-switching = ["wasmtime/stack-switching"]
+rr = ["wasmtime/rr"]
+rr-validate = ["wasmtime/rr-validate"]

crates/cli-flags/src/lib.rs

@@ -478,6 +478,25 @@ wasmtime_option_group! {
     }
 }
 
+wasmtime_option_group! {
+    #[derive(PartialEq, Clone, Deserialize)]
+    #[serde(rename_all = "kebab-case", deny_unknown_fields)]
+    pub struct RecordOptions {
+        /// Filesystem endpoint to store the recorded execution trace
+        pub path: Option<String>,
+        /// Include (optional) signatures to facilitate validation checks during replay
+        /// (see `wasmtime replay` for details).
+        pub validation_metadata: Option<bool>,
+        /// Window size of internal buffering for record events (large windows offer more opportunities
+        /// for coalescing events at the cost of memory usage).
+        pub event_window_size: Option<usize>,
+    }
+
+    enum Record {
+        ...
+    }
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub struct WasiNnGraph {
     pub format: String,
@@ -528,6 +547,18 @@ pub struct CommonOptions {
     #[serde(skip)]
     wasi_raw: Vec<opt::CommaSeparated<Wasi>>,
 
+    /// Options to enable and configure execution recording, `-R help` to see all.
+    ///
+    /// Generates of a serialized trace of the Wasm module execution that captures all
+    /// non-determinism observable by the module. This trace can subsequently be
+    /// re-executed in a determinstic, embedding-agnostic manner (see the `wasmtime replay` command).
+    ///
+    /// Note: Minimal configs for deterministic Wasm semantics will be
+    /// enforced during recording by default (NaN canonicalization, deterministic relaxed SIMD)
+    #[arg(short = 'R', long = "record", value_name = "KEY[=VAL[,..]]")]
+    #[serde(skip)]
+    record_raw: Vec<opt::CommaSeparated<Record>>,
+
     // These fields are filled in by the `configure` method below via the
     // options parsed from the CLI above. This is what the CLI should use.
     #[arg(skip)]
@@ -554,6 +585,10 @@ pub struct CommonOptions {
     #[serde(rename = "wasi", default)]
     pub wasi: WasiOptions,
 
+    #[arg(skip)]
+    #[serde(rename = "record", default)]
+    pub record: RecordOptions,
+
     /// The target triple; default is the host triple
     #[arg(long, value_name = "TARGET")]
     #[serde(skip)]
@@ -600,12 +635,14 @@ impl CommonOptions {
             debug_raw: Vec::new(),
             wasm_raw: Vec::new(),
             wasi_raw: Vec::new(),
+            record_raw: Vec::new(),
             configured: true,
             opts: Default::default(),
             codegen: Default::default(),
             debug: Default::default(),
             wasm: Default::default(),
             wasi: Default::default(),
+            record: Default::default(),
             target: None,
             config: None,
         }
@@ -623,12 +660,14 @@ impl CommonOptions {
             self.debug = toml_options.debug;
             self.wasm = toml_options.wasm;
             self.wasi = toml_options.wasi;
+            self.record = toml_options.record;
         }
         self.opts.configure_with(&self.opts_raw);
         self.codegen.configure_with(&self.codegen_raw);
         self.debug.configure_with(&self.debug_raw);
         self.wasm.configure_with(&self.wasm_raw);
         self.wasi.configure_with(&self.wasi_raw);
+        self.record.configure_with(&self.record_raw);
         Ok(())
     }
 
@@ -970,6 +1009,35 @@ impl CommonOptions {
             true => err,
         }
 
+        let record = &self.record;
+        match_feature! {
+            ["rr" : record.path.clone()]
+            path => {
+                use std::{io::BufWriter, sync::Arc};
+                use wasmtime::{RecordConfig, RecordSettings};
+                let default_settings = RecordSettings::default();
+                match_feature! {
+                    ["rr-validate": record.validation_metadata]
+                    _v => (),
+                    _ => err,
+                }
+                config.enable_record(RecordConfig {
+                    writer_initializer: Arc::new(move || {
+                        Box::new(BufWriter::new(fs::File::create(&path).unwrap()))
+                    }),
+                    settings: RecordSettings {
+                        add_validation: record
+                            .validation_metadata
+                            .unwrap_or(default_settings.add_validation),
+                        event_window_size: record
+                            .event_window_size
+                            .unwrap_or(default_settings.event_window_size),
+                    },
+                })?
+            },
+            _ => err,
+        }
+
         Ok(config)
     }
 
@@ -1074,6 +1142,7 @@ mod tests {
             [debug]
             [wasm]
             [wasi]
+            [record]
         "#;
         let mut common_options: CommonOptions = toml::from_str(basic_toml).unwrap();
         common_options.config(None).unwrap();
@@ -1195,6 +1264,8 @@ impl fmt::Display for CommonOptions {
             wasm,
             wasi_raw,
             wasi,
+            record_raw,
+            record,
             configured,
             target,
             config,
@@ -1211,13 +1282,15 @@ impl fmt::Display for CommonOptions {
         let wasi_flags;
         let wasm_flags;
         let debug_flags;
+        let record_flags;
 
         if *configured {
             codegen_flags = codegen.to_options();
             debug_flags = debug.to_options();
             wasi_flags = wasi.to_options();
             wasm_flags = wasm.to_options();
             opts_flags = opts.to_options();
+            record_flags = record.to_options();
         } else {
             codegen_flags = codegen_raw
                 .iter()
@@ -1228,6 +1301,11 @@ impl fmt::Display for CommonOptions {
             wasi_flags = wasi_raw.iter().flat_map(|t| t.0.iter()).cloned().collect();
             wasm_flags = wasm_raw.iter().flat_map(|t| t.0.iter()).cloned().collect();
             opts_flags = opts_raw.iter().flat_map(|t| t.0.iter()).cloned().collect();
+            record_flags = record_raw
+                .iter()
+                .flat_map(|t| t.0.iter())
+                .cloned()
+                .collect();
         }
 
         for flag in codegen_flags {
@@ -1245,6 +1323,9 @@ impl fmt::Display for CommonOptions {
         for flag in debug_flags {
             write!(f, "-D{flag} ")?;
         }
+        for flag in record_flags {
+            write!(f, "-R{flag} ")?;
+        }
 
         Ok(())
     }

crates/environ/src/component/artifacts.rs

@@ -18,6 +18,8 @@ pub struct ComponentArtifacts {
     pub types: ComponentTypes,
     /// Serialized metadata about all included core wasm modules.
     pub static_modules: PrimaryMap<StaticModuleIndex, CompiledModuleInfo>,
+    /// A SHA-256 checksum of the source Wasm binary from which the component was compiled
+    pub checksum: [u8; 32],
 }
 
 /// Runtime state that a component retains to support its operation.

crates/wasmtime/Cargo.toml

@@ -45,7 +45,7 @@ wat = { workspace = true, optional = true }
 serde = { workspace = true }
 serde_derive = { workspace = true }
 serde_json = { workspace = true, optional = true }
-postcard = { workspace = true }
+postcard = { workspace = true, optional = true }
 indexmap = { workspace = true }
 once_cell = { version = "1.12.0", optional = true }
 rayon = { version = "1.0", optional = true }
@@ -62,6 +62,8 @@ smallvec = { workspace = true, optional = true }
 hashbrown = { workspace = true, features = ["default-hasher"] }
 bitflags = { workspace = true }
 futures = { workspace = true, features = ["alloc"], optional = true }
+embedded-io = { version = "0.6.1", features = ["alloc"], optional = true }
+sha2 = "0.10.2"
 
 [target.'cfg(target_os = "windows")'.dependencies.windows-sys]
 workspace = true
@@ -325,6 +327,7 @@ addr2line = ["dep:addr2line", "dep:gimli", "std"]
 # Many features of the Wasmtime crate implicitly require this `std` feature.
 # This will be automatically enabled if necessary.
 std = [
+  'dep:postcard',
   'postcard/use-std',
   'wasmtime-environ/std',
   'object/std',
@@ -393,3 +396,18 @@ component-model-async = [
   "wasmtime-component-macro?/component-model-async",
   "dep:futures"
 ]
+
+
+# `rr` only configures the base infrastructure and is not practically useful by itself
+# Use `rr-component` or `rr-core` for generating record/replay events for components/core wasm
+# respectively
+rr = ["dep:embedded-io", "dep:postcard"]
+# RR for components
+rr-component = ["component-model", "rr"]
+# RR for core wasm
+rr-core = ["rr"]
+
+# Support for validation signatures/checks during record/replay respectively.
+# This feature only makes sense if 'rr-component' or 'rr-core' is enabled
+rr-validate = ["rr"]
+

crates/wasmtime/src/compile.rs

@@ -26,6 +26,7 @@ use crate::Engine;
 use crate::hash_map::HashMap;
 use crate::hash_set::HashSet;
 use crate::prelude::*;
+use sha2::{Digest, Sha256};
 use std::{
     any::Any,
     borrow::Cow,
@@ -198,6 +199,7 @@ pub(crate) fn build_component_artifacts<T: FinishedObject>(
         ty,
         types,
         static_modules: compilation_artifacts.modules,
+        checksum: Sha256::digest(binary).into(),
     };
     object.serialize_info(&artifacts);