Duplicate page size determination in wasmtime-fiber

Currently Wasmtime has a function `crate::runtime::vm::host_page_size`
but this isn't reachable from the `wasmtime-fiber` crate and instead tha
crate uses `rustix::param::page_size` to determine the host page size.
It looks like this usage of `rustix` is causing a panic in #10802.
Ideally `wasmtime-fiber` would be able to use the same function but the
crate separation does not currently make that feasible. For now
duplicate the logic of `wasmtime` into `wasmtime-fiber` as it's modest
enough to ensure that this does not panic.

Closes #10802

Author: alexcrichton

Cargo.lock

@@ -88,7 +88,7 @@ http = { workspace = true, optional = true }
 http-body-util = { workspace = true, optional = true }
 
 [target.'cfg(unix)'.dependencies]
-rustix = { workspace = true, features = ["mm", "param", "process"] }
+rustix = { workspace = true, features = ["mm", "process"] }
 
 [dev-dependencies]
 # depend again on wasmtime to activate its default features for tests
@@ -133,6 +133,9 @@ cranelift-native = { workspace = true }
 [target.'cfg(windows)'.dev-dependencies]
 windows-sys = { workspace = true, features = ["Win32_System_Memory"] }
 
+[target.'cfg(unix)'.dev-dependencies]
+rustix = { workspace = true, features = ["param"] }
+
 [build-dependencies]
 anyhow = { workspace = true, features = ['std'] }
 

Cargo.toml

@@ -18,7 +18,8 @@ wasmtime-versioned-export-macros = { workspace = true }
 wasmtime-asm-macros = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
-rustix = { workspace = true, features = ["mm", "param"] }
+rustix = { workspace = true, features = ["mm"] }
+libc = { workspace = true }
 
 [target.'cfg(windows)'.dependencies.windows-sys]
 workspace = true

crates/fiber/Cargo.toml

@@ -273,13 +273,17 @@ mod tests {
     use std::cell::Cell;
     use std::rc::Rc;
 
+    fn fiber_stack(size: usize) -> FiberStack {
+        FiberStack::new(size, false).unwrap()
+    }
+
     #[test]
     fn small_stacks() {
-        Fiber::<(), (), ()>::new(FiberStack::new(0, false).unwrap(), |_, _| {})
+        Fiber::<(), (), ()>::new(fiber_stack(0), |_, _| {})
             .unwrap()
             .resume(())
             .unwrap();
-        Fiber::<(), (), ()>::new(FiberStack::new(1, false).unwrap(), |_, _| {})
+        Fiber::<(), (), ()>::new(fiber_stack(1), |_, _| {})
             .unwrap()
             .resume(())
             .unwrap();
@@ -289,11 +293,10 @@ mod tests {
     fn smoke() {
         let hit = Rc::new(Cell::new(false));
         let hit2 = hit.clone();
-        let fiber =
-            Fiber::<(), (), ()>::new(FiberStack::new(1024 * 1024, false).unwrap(), move |_, _| {
-                hit2.set(true);
-            })
-            .unwrap();
+        let fiber = Fiber::<(), (), ()>::new(fiber_stack(1024 * 1024), move |_, _| {
+            hit2.set(true);
+        })
+        .unwrap();
         assert!(!hit.get());
         fiber.resume(()).unwrap();
         assert!(hit.get());
@@ -303,13 +306,12 @@ mod tests {
     fn suspend_and_resume() {
         let hit = Rc::new(Cell::new(false));
         let hit2 = hit.clone();
-        let fiber =
-            Fiber::<(), (), ()>::new(FiberStack::new(1024 * 1024, false).unwrap(), move |_, s| {
-                s.suspend(());
-                hit2.set(true);
-                s.suspend(());
-            })
-            .unwrap();
+        let fiber = Fiber::<(), (), ()>::new(fiber_stack(1024 * 1024), move |_, s| {
+            s.suspend(());
+            hit2.set(true);
+            s.suspend(());
+        })
+        .unwrap();
         assert!(!hit.get());
         assert!(fiber.resume(()).is_err());
         assert!(!hit.get());
@@ -348,16 +350,13 @@ mod tests {
         }
 
         fn run_test() {
-            let fiber = Fiber::<(), (), ()>::new(
-                FiberStack::new(1024 * 1024, false).unwrap(),
-                move |(), s| {
-                    assert_contains_host();
-                    s.suspend(());
-                    assert_contains_host();
-                    s.suspend(());
-                    assert_contains_host();
-                },
-            )
+            let fiber = Fiber::<(), (), ()>::new(fiber_stack(1024 * 1024), move |(), s| {
+                assert_contains_host();
+                s.suspend(());
+                assert_contains_host();
+                s.suspend(());
+                assert_contains_host();
+            })
             .unwrap();
             assert!(fiber.resume(()).is_err());
             assert!(fiber.resume(()).is_err());
@@ -374,13 +373,10 @@ mod tests {
 
         let a = Rc::new(Cell::new(false));
         let b = SetOnDrop(a.clone());
-        let fiber = Fiber::<(), (), ()>::new(
-            FiberStack::new(1024 * 1024, false).unwrap(),
-            move |(), _s| {
-                let _ = &b;
-                panic!();
-            },
-        )
+        let fiber = Fiber::<(), (), ()>::new(fiber_stack(1024 * 1024), move |(), _s| {
+            let _ = &b;
+            panic!();
+        })
         .unwrap();
         assert!(panic::catch_unwind(AssertUnwindSafe(|| fiber.resume(()))).is_err());
         assert!(a.get());
@@ -396,14 +392,11 @@ mod tests {
 
     #[test]
     fn suspend_and_resume_values() {
-        let fiber = Fiber::new(
-            FiberStack::new(1024 * 1024, false).unwrap(),
-            move |first, s| {
-                assert_eq!(first, 2.0);
-                assert_eq!(s.suspend(4), 3.0);
-                "hello".to_string()
-            },
-        )
+        let fiber = Fiber::new(fiber_stack(1024 * 1024), move |first, s| {
+            assert_eq!(first, 2.0);
+            assert_eq!(s.suspend(4), 3.0);
+            "hello".to_string()
+        })
         .unwrap();
         assert_eq!(fiber.resume(2.0), Err(4));
         assert_eq!(fiber.resume(3.0), Ok("hello".to_string()));

crates/fiber/src/lib.rs

@@ -36,6 +36,7 @@ use std::cell::Cell;
 use std::io;
 use std::ops::Range;
 use std::ptr;
+use std::sync::atomic::{AtomicUsize, Ordering};
 
 pub type Error = io::Error;
 
@@ -59,8 +60,26 @@ enum FiberStackStorage {
     Custom(Box<dyn RuntimeFiberStack>),
 }
 
+// FIXME: this is a duplicate copy of what's already in the `wasmtime` crate. If
+// this changes that should change over there, and ideally one day we should
+// probably deduplicate the two.
+fn host_page_size() -> usize {
+    static PAGE_SIZE: AtomicUsize = AtomicUsize::new(0);
+
+    return match PAGE_SIZE.load(Ordering::Relaxed) {
+        0 => {
+            let size = unsafe { libc::sysconf(libc::_SC_PAGESIZE).try_into().unwrap() };
+            assert!(size != 0);
+            PAGE_SIZE.store(size, Ordering::Relaxed);
+            size
+        }
+        n => n,
+    };
+}
+
 impl FiberStack {
     pub fn new(size: usize, zeroed: bool) -> io::Result<Self> {
+        let page_size = host_page_size();
         // The anonymous `mmap`s we use for `FiberStackStorage` are alawys
         // zeroed.
         let _ = zeroed;
@@ -70,7 +89,6 @@ impl FiberStack {
         if cfg!(asan) {
             return Self::from_custom(asan::new_fiber_stack(size)?);
         }
-        let page_size = rustix::param::page_size();
         let stack = MmapFiberStack::new(size)?;
 
         // An `MmapFiberStack` allocates a guard page at the bottom of the
@@ -102,7 +120,7 @@ impl FiberStack {
 
     pub fn from_custom(custom: Box<dyn RuntimeFiberStack>) -> io::Result<Self> {
         let range = custom.range();
-        let page_size = rustix::param::page_size();
+        let page_size = host_page_size();
         let start_ptr = range.start as *mut u8;
         assert!(
             start_ptr.align_offset(page_size) == 0,
@@ -153,7 +171,7 @@ impl MmapFiberStack {
     fn new(size: usize) -> io::Result<Self> {
         // Round up our stack size request to the nearest multiple of the
         // page size.
-        let page_size = rustix::param::page_size();
+        let page_size = host_page_size();
         let size = if size == 0 {
             page_size
         } else {
@@ -306,10 +324,9 @@ impl Suspend {
 /// called around every stack switch with some other fiddly bits as well.
 #[cfg(asan)]
 mod asan {
-    use super::{FiberStack, MmapFiberStack, RuntimeFiberStack};
+    use super::{FiberStack, MmapFiberStack, RuntimeFiberStack, host_page_size};
     use alloc::boxed::Box;
     use alloc::vec::Vec;
-    use rustix::param::page_size;
     use std::mem::ManuallyDrop;
     use std::ops::Range;
     use std::sync::Mutex;
@@ -426,7 +443,8 @@ mod asan {
     static FIBER_STACKS: Mutex<Vec<MmapFiberStack>> = Mutex::new(Vec::new());
 
     pub fn new_fiber_stack(size: usize) -> std::io::Result<Box<dyn RuntimeFiberStack>> {
-        let needed_size = size + page_size();
+        let page_size = host_page_size();
+        let needed_size = size + page_size;
         let mut stacks = FIBER_STACKS.lock().unwrap();
 
         let stack = match stacks.iter().position(|i| needed_size <= i.mapping_len) {
@@ -436,7 +454,9 @@ mod asan {
             // ... otherwise allocate a brand new stack.
             None => MmapFiberStack::new(size)?,
         };
-        let stack = AsanFiberStack(ManuallyDrop::new(stack));
+        let stack = AsanFiberStack {
+            mmap: ManuallyDrop::new(stack),
+        };
         Ok(Box::new(stack))
     }
 
@@ -445,27 +465,31 @@ mod asan {
     ///
     /// On drop this stack will return the interior stack to the global
     /// `FIBER_STACKS` list.
-    struct AsanFiberStack(ManuallyDrop<MmapFiberStack>);
+    struct AsanFiberStack {
+        mmap: ManuallyDrop<MmapFiberStack>,
+    }
 
     unsafe impl RuntimeFiberStack for AsanFiberStack {
         fn top(&self) -> *mut u8 {
-            self.0.mapping_base.wrapping_byte_add(self.0.mapping_len)
+            self.mmap
+                .mapping_base
+                .wrapping_byte_add(self.mmap.mapping_len)
         }
 
         fn range(&self) -> Range<usize> {
-            let base = self.0.mapping_base as usize;
-            let end = base + self.0.mapping_len;
-            base + page_size()..end
+            let base = self.mmap.mapping_base as usize;
+            let end = base + self.mmap.mapping_len;
+            base + host_page_size()..end
         }
 
         fn guard_range(&self) -> Range<*mut u8> {
-            self.0.mapping_base..self.0.mapping_base.wrapping_add(page_size())
+            self.mmap.mapping_base..self.mmap.mapping_base.wrapping_add(host_page_size())
         }
     }
 
     impl Drop for AsanFiberStack {
         fn drop(&mut self) {
-            let stack = unsafe { ManuallyDrop::take(&mut self.0) };
+            let stack = unsafe { ManuallyDrop::take(&mut self.mmap) };
             FIBER_STACKS.lock().unwrap().push(stack);
         }
     }

crates/fiber/src/unix.rs

@@ -23,7 +23,7 @@ object = { workspace = true, optional = true }
 wasmtime-versioned-export-macros = { workspace = true }
 
 [target.'cfg(target_os = "linux")'.dependencies]
-rustix = { workspace = true, features = ["mm", "param", "time"], optional = true }
+rustix = { workspace = true, features = ["mm", "time"], optional = true }
 
 [features]
 gdb_jit_int = []

crates/jit-debug/Cargo.toml

@@ -131,6 +131,7 @@ pub struct JitDumpFile {
     jitdump_file: File,
 
     map_addr: usize,
+    map_len: usize,
 
     /// Unique identifier for jitted code
     code_index: u64,
@@ -157,10 +158,11 @@ impl JitDumpFile {
         //
         // To match what some perf examples are doing we keep this `mmap` alive
         // until this agent goes away.
+        let map_len = 1024;
         let map_addr = unsafe {
             let ptr = rustix::mm::mmap(
                 ptr::null_mut(),
-                rustix::param::page_size(),
+                map_len,
                 rustix::mm::ProtFlags::EXEC | rustix::mm::ProtFlags::READ,
                 rustix::mm::MapFlags::PRIVATE,
                 &jitdump_file,
@@ -171,6 +173,7 @@ impl JitDumpFile {
         let mut state = JitDumpFile {
             jitdump_file,
             map_addr,
+            map_len,
             code_index: 0,
             e_machine,
         };
@@ -283,7 +286,7 @@ impl JitDumpFile {
 impl Drop for JitDumpFile {
     fn drop(&mut self) {
         unsafe {
-            rustix::mm::munmap(self.map_addr as *mut _, rustix::param::page_size()).unwrap();
+            rustix::mm::munmap(self.map_addr as *mut _, self.map_len).unwrap();
         }
     }
 }

crates/jit-debug/src/perf_jitdump.rs

@@ -449,6 +449,8 @@ impl ModuleRuntimeInfo {
 /// Returns the host OS page size, in bytes.
 #[cfg(has_virtual_memory)]
 pub fn host_page_size() -> usize {
+    // NB: this function is duplicated in `crates/fiber/src/unix.rs` so if this
+    // changes that should probably get updated as well.
     static PAGE_SIZE: AtomicUsize = AtomicUsize::new(0);
 
     return match PAGE_SIZE.load(Ordering::Relaxed) {

crates/wasmtime/src/runtime/vm.rs

@@ -1,7 +1,8 @@
 #![cfg_attr(not(asan), allow(dead_code))]
 
+use crate::PoolConcurrencyLimitError;
 use crate::prelude::*;
-use crate::{PoolConcurrencyLimitError, runtime::vm::PoolingInstanceAllocatorConfig};
+use crate::runtime::vm::PoolingInstanceAllocatorConfig;
 use std::sync::atomic::{AtomicU64, Ordering};
 
 /// A generic implementation of a stack pool.

crates/wasmtime/src/runtime/vm/instance/allocator/pooling/generic_stack_pool.rs

@@ -66,6 +66,8 @@ pub unsafe fn decommit_pages(addr: *mut u8, len: usize) -> io::Result<()> {
     Ok(())
 }
 
+// NB: this function is duplicated in `crates/fiber/src/unix.rs` so if this
+// changes that should probably get updated as well.
 pub fn get_page_size() -> usize {
     unsafe { libc::sysconf(libc::_SC_PAGESIZE).try_into().unwrap() }
 }