Move memory_init_cow option to Tunables (#9632)

This commit moves the configuration option from `Config` to `Tunables`
to ensure that the memory allocation backend has access to it and then
it's used to specifically avoid choosing a malloc-based memory because
CoW isn't compatible with malloc.

Author: alexcrichton

crates/environ/src/tunables.rs

@@ -117,6 +117,9 @@ define_tunables! {
         /// Whether or not the host will be using native signals (e.g. SIGILL,
         /// SIGSEGV, etc) to implement traps.
         pub signals_based_traps: bool,
+
+        /// Whether CoW images might be used to initialize linear memories.
+        pub memory_init_cow: bool,
     }
 
     pub struct ConfigTunables {
@@ -175,6 +178,7 @@ impl Tunables {
             relaxed_simd_deterministic: false,
             winch_callable: false,
             signals_based_traps: true,
+            memory_init_cow: true,
         }
     }
 

crates/wasmtime/src/compile.rs

@@ -796,7 +796,7 @@ impl FunctionIndices {
                 // can either at runtime be implemented as a single memcpy to
                 // initialize memory or otherwise enabling virtual-memory-tricks
                 // such as mmap'ing from a file to get copy-on-write.
-                if engine.config().memory_init_cow {
+                if engine.tunables().memory_init_cow {
                     let align = compiler.page_size_align();
                     let max_always_allowed = engine.config().memory_guaranteed_dense_image_size;
                     translation.try_static_init(align, max_always_allowed);

crates/wasmtime/src/config.rs

@@ -144,7 +144,6 @@ pub struct Config {
     pub(crate) async_support: bool,
     pub(crate) module_version: ModuleVersionStrategy,
     pub(crate) parallel_compilation: bool,
-    pub(crate) memory_init_cow: bool,
     pub(crate) memory_guaranteed_dense_image_size: u64,
     pub(crate) force_memory_init_memfd: bool,
     pub(crate) wmemcheck: bool,
@@ -246,9 +245,6 @@ impl Config {
             async_support: false,
             module_version: ModuleVersionStrategy::default(),
             parallel_compilation: !cfg!(miri),
-            // If signals are disabled then virtual memory is probably mostly
-            // disabled so also disable the use of CoW by default.
-            memory_init_cow: cfg!(feature = "signals-based-traps"),
             memory_guaranteed_dense_image_size: 16 << 20,
             force_memory_init_memfd: false,
             wmemcheck: false,
@@ -1791,7 +1787,7 @@ impl Config {
     /// [IPI]: https://en.wikipedia.org/wiki/Inter-processor_interrupt
     #[cfg(feature = "signals-based-traps")]
     pub fn memory_init_cow(&mut self, enable: bool) -> &mut Self {
-        self.memory_init_cow = enable;
+        self.tunables.memory_init_cow = Some(enable);
         self
     }
 
@@ -2051,6 +2047,7 @@ impl Config {
             tunables.memory_reservation = 0;
             tunables.memory_guard_size = 0;
             tunables.memory_reservation_for_growth = 1 << 20; // 1MB
+            tunables.memory_init_cow = false;
         }
 
         self.tunables.configure(&mut tunables);
@@ -2081,7 +2078,7 @@ impl Config {
         // the defaults here.
         if !cfg!(feature = "signals-based-traps") {
             assert!(!tunables.signals_based_traps);
-            assert!(!self.memory_init_cow);
+            assert!(!tunables.memory_init_cow);
         }
 
         Ok((tunables, features))

crates/wasmtime/src/engine/serialization.rs

@@ -376,6 +376,7 @@ impl Metadata<'_> {
             relaxed_simd_deterministic,
             winch_callable,
             signals_based_traps,
+            memory_init_cow,
             // This doesn't affect compilation, it's just a runtime setting.
             memory_reservation_for_growth: _,
 
@@ -438,6 +439,11 @@ impl Metadata<'_> {
             other.signals_based_traps,
             "Signals-based traps",
         )?;
+        Self::check_bool(
+            memory_init_cow,
+            other.memory_init_cow,
+            "memory initialization with CoW",
+        )?;
 
         Ok(())
     }

crates/wasmtime/src/runtime/module.rs

@@ -1163,7 +1163,7 @@ fn _assert_send_sync() {
 fn memory_images(engine: &Engine, module: &CompiledModule) -> Result<Option<ModuleMemoryImages>> {
     // If initialization via copy-on-write is explicitly disabled in
     // configuration then this path is skipped entirely.
-    if !engine.config().memory_init_cow {
+    if !engine.tunables().memory_init_cow {
         return Ok(None);
     }
 

crates/wasmtime/src/runtime/vm/memory.rs

@@ -131,6 +131,7 @@ impl RuntimeMemoryCreator for DefaultMemoryCreator {
         if tunables.signals_based_traps
             || tunables.memory_guard_size > 0
             || tunables.memory_reservation > 0
+            || tunables.memory_init_cow
         {
             return Ok(Box::new(MmapMemory::new(ty, tunables, minimum, maximum)?));
         }

crates/wasmtime/src/runtime/vm/memory/malloc.rs

@@ -34,6 +34,9 @@ impl MallocMemory {
         if tunables.memory_reservation > 0 {
             bail!("malloc memory is only compatible with no ahead-of-time memory reservation");
         }
+        if tunables.memory_init_cow {
+            bail!("malloc memory cannot be used with CoW images");
+        }
 
         let byte_size = minimum
             .checked_add(