fix(fspy): use memfd for Linux shared memory

Replace the Linux /dev/shm-backed adapter with a sealed memfd mapping. Each client connection receives the descriptor immediately from a broker task on the ambient Tokio runtime. Dropping the owner cancels the broker, while already-open mappings remain valid.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Co-authored-by: GPT-5 Codex <codex@openai.com>

Author: wan9chi

CHANGELOG.md

@@ -1,5 +1,6 @@
 # Changelog
 
+- **Fixed** Linux file-access tracking no longer consumes the `/dev/shm` mount used by containers and Kubernetes runners ([#353](https://github.com/voidzero-dev/vite-task/issues/353), [#523](https://github.com/voidzero-dev/vite-task/pull/523)).
 - **Fixed** Windows automatic input tracking now records executable image reads when process creation performs the lookup inside `NtCreateUserProcess` ([#518](https://github.com/voidzero-dev/vite-task/pull/518)).
 - **Fixed** Failures while waiting for a started task process to exit no longer incorrectly say the process failed to spawn ([#515](https://github.com/voidzero-dev/vite-task/pull/515)).
 - **Fixed** Missing env vars requested through `@voidzero-dev/vite-task-client` now return `undefined` instead of `null`, preserving Vite production `NODE_ENV` semantics when builds run through `vp run` ([#508](https://github.com/voidzero-dev/vite-task/pull/508)).

Cargo.lock

@@ -116,6 +116,7 @@ ref-cast = "1.0.24"
 regex = "1.11.3"
 rusqlite = "0.39.0"
 rustc-hash = "2.1.1"
+rustix = "1.1"
 # SeccompAction::UserNotif (SECCOMP_RET_USER_NOTIF) was added after the latest published release (v0.5.0)
 seccompiler = { git = "https://github.com/rust-vmm/seccompiler", rev = "08587106340b8e3cb361c7561411510039436857" }
 serde = "1.0.219"

Cargo.toml

@@ -28,6 +28,9 @@ ctor = { workspace = true }
 rustc-hash = { workspace = true }
 subprocess_test = { workspace = true }
 
+[target.'cfg(target_os = "linux")'.dev-dependencies]
+tokio = { workspace = true, features = ["net", "rt-multi-thread", "time"] }
+
 [lints]
 workspace = true
 

crates/fspy_shared/Cargo.toml

@@ -117,9 +117,12 @@ impl Deref for Sender {
     }
 }
 
-#[expect(
-    clippy::non_send_fields_in_send_ty,
-    reason = "`Sender` holds a shared file lock that ensures there's no reader, so `shm` can be safely written to"
+#[cfg_attr(
+    not(target_os = "linux"),
+    expect(
+        clippy::non_send_fields_in_send_ty,
+        reason = "`Sender` holds a shared file lock that ensures there's no reader, so `shm` can be safely written to"
+    )
 )]
 /// SAFETY: `Sender` holds a shared file lock that ensures there's no reader, so `shm` can be safely written to.
 unsafe impl Send for Sender {}
@@ -135,9 +138,12 @@ pub struct Receiver {
     shm: Shm,
 }
 
-#[expect(
-    clippy::non_send_fields_in_send_ty,
-    reason = "Receiver doesn't read or write `shm`. It only pass it to `ReceiverLockGuard` under the lock"
+#[cfg_attr(
+    not(target_os = "linux"),
+    expect(
+        clippy::non_send_fields_in_send_ty,
+        reason = "Receiver doesn't read or write `shm`. It only passes it to `ReceiverLockGuard` under the lock"
+    )
 )]
 /// SAFETY: `Receiver` doesn't read or write `shm`. It only passes it to `ReceiverLockGuard` under the lock.
 unsafe impl Send for Receiver {}
@@ -204,78 +210,102 @@ mod tests {
 
     use super::*;
 
+    /// Runs `test` with an ambient tokio runtime on Linux, where `channel`
+    /// spawns the shared-memory broker onto it. The test body runs on the
+    /// test thread, so it may block without starving the broker.
+    fn in_service_runtime<T>(test: impl FnOnce() -> T) -> T {
+        #[cfg(target_os = "linux")]
+        let runtime = tokio::runtime::Builder::new_multi_thread()
+            .worker_threads(1)
+            .enable_io()
+            .enable_time()
+            .build()
+            .unwrap();
+        #[cfg(target_os = "linux")]
+        let _guard = runtime.enter();
+        test()
+    }
+
     #[test]
     fn smoke() {
-        let (conf, receiver) = channel(100).unwrap();
-        let cmd = command_for_fn!(conf, |conf: ChannelConf| {
-            let sender = conf.sender().unwrap();
-            let frame_size = NonZeroUsize::new(2).unwrap();
-            let mut frame = sender.claim_frame(frame_size).unwrap();
-            frame.copy_from_slice(&[4, 2]);
-        });
-        assert!(std::process::Command::from(cmd).status().unwrap().success());
+        in_service_runtime(|| {
+            let (conf, receiver) = channel(100).unwrap();
+            let cmd = command_for_fn!(conf, |conf: ChannelConf| {
+                let sender = conf.sender().unwrap();
+                let frame_size = NonZeroUsize::new(2).unwrap();
+                let mut frame = sender.claim_frame(frame_size).unwrap();
+                frame.copy_from_slice(&[4, 2]);
+            });
+            assert!(std::process::Command::from(cmd).status().unwrap().success());
 
-        let lock = receiver.lock().unwrap();
-        let mut frames = lock.iter_frames();
+            let lock = receiver.lock().unwrap();
+            let mut frames = lock.iter_frames();
 
-        let received_frame = frames.next().unwrap();
-        assert_eq!(received_frame, &[4, 2]);
+            let received_frame = frames.next().unwrap();
+            assert_eq!(received_frame, &[4, 2]);
 
-        assert!(frames.next().is_none());
+            assert!(frames.next().is_none());
+        });
     }
 
     #[test]
     #[expect(clippy::print_stdout, reason = "test diagnostics")]
     fn forbid_new_senders_after_locked() {
-        let (conf, receiver) = channel(42).unwrap();
-        let _lock = receiver.lock().unwrap();
+        in_service_runtime(|| {
+            let (conf, receiver) = channel(42).unwrap();
+            let _lock = receiver.lock().unwrap();
 
-        let cmd = command_for_fn!(conf, |conf: ChannelConf| {
-            print!("{}", conf.sender().is_ok());
+            let cmd = command_for_fn!(conf, |conf: ChannelConf| {
+                print!("{}", conf.sender().is_ok());
+            });
+            let output = std::process::Command::from(cmd).output().unwrap();
+            assert_eq!(B(&output.stdout), B("false"));
         });
-        let output = std::process::Command::from(cmd).output().unwrap();
-        assert_eq!(B(&output.stdout), B("false"));
     }
 
     #[test]
     #[expect(clippy::print_stdout, reason = "test diagnostics")]
     fn forbid_new_senders_after_receiver_dropped() {
-        let (conf, receiver) = channel(42).unwrap();
-        drop(receiver);
+        in_service_runtime(|| {
+            let (conf, receiver) = channel(42).unwrap();
+            drop(receiver);
 
-        let cmd = command_for_fn!(conf, |conf: ChannelConf| {
-            print!("{}", conf.sender().is_ok());
+            let cmd = command_for_fn!(conf, |conf: ChannelConf| {
+                print!("{}", conf.sender().is_ok());
+            });
+            let output = std::process::Command::from(cmd).output().unwrap();
+            assert_eq!(B(&output.stdout), B("false"));
         });
-        let output = std::process::Command::from(cmd).output().unwrap();
-        assert_eq!(B(&output.stdout), B("false"));
     }
 
     #[test]
     fn concurrent_senders() {
-        let (conf, receiver) = channel(8192).unwrap();
-        for i in 0u16..200 {
-            let cmd = command_for_fn!((conf.clone(), i), |(conf, i): (ChannelConf, u16)| {
-                let sender = conf.sender().unwrap();
-                let data_to_send = i.to_string();
-                sender
-                    .claim_frame(NonZeroUsize::new(data_to_send.len()).unwrap())
-                    .unwrap()
-                    .copy_from_slice(data_to_send.as_bytes());
-            });
-            let output = std::process::Command::from(cmd).output().unwrap();
-            assert!(
-                output.status.success(),
-                "Failed to send in iteration {}: {:?}",
-                i,
-                B(&output.stderr)
-            );
-        }
-        let lock = receiver.lock().unwrap();
-        let mut received_values: Vec<u16> = lock
-            .iter_frames()
-            .map(|frame| from_utf8(frame).unwrap().parse::<u16>().unwrap())
-            .collect();
-        received_values.sort_unstable();
-        assert_eq!(received_values, (0u16..200).collect::<Vec<u16>>());
+        in_service_runtime(|| {
+            let (conf, receiver) = channel(8192).unwrap();
+            for i in 0u16..200 {
+                let cmd = command_for_fn!((conf.clone(), i), |(conf, i): (ChannelConf, u16)| {
+                    let sender = conf.sender().unwrap();
+                    let data_to_send = i.to_string();
+                    sender
+                        .claim_frame(NonZeroUsize::new(data_to_send.len()).unwrap())
+                        .unwrap()
+                        .copy_from_slice(data_to_send.as_bytes());
+                });
+                let output = std::process::Command::from(cmd).output().unwrap();
+                assert!(
+                    output.status.success(),
+                    "Failed to send in iteration {}: {:?}",
+                    i,
+                    B(&output.stderr)
+                );
+            }
+            let lock = receiver.lock().unwrap();
+            let mut received_values: Vec<u16> = lock
+                .iter_frames()
+                .map(|frame| from_utf8(frame).unwrap().parse::<u16>().unwrap())
+                .collect();
+            received_values.sort_unstable();
+            assert_eq!(received_values, (0u16..200).collect::<Vec<u16>>());
+        });
     }
 }

crates/fspy_shared/src/ipc/channel/mod.rs

@@ -672,6 +672,18 @@ mod tests {
 
         const SHM_SIZE: usize = 1024 * 1024;
 
+        // On Linux, `fspy_shm::create` spawns the mapping's broker onto the
+        // ambient tokio runtime, which serves the child processes' opens.
+        #[cfg(target_os = "linux")]
+        let runtime = tokio::runtime::Builder::new_multi_thread()
+            .worker_threads(1)
+            .enable_io()
+            .enable_time()
+            .build()
+            .unwrap();
+        #[cfg(target_os = "linux")]
+        let _guard = runtime.enter();
+
         let shm = fspy_shm::create(SHM_SIZE).unwrap();
         let shm_name = shm.id().to_owned();
 

crates/fspy_shared/src/ipc/channel/shm_io.rs

@@ -7,12 +7,22 @@ license.workspace = true
 publish = false
 rust-version.workspace = true
 
-[dependencies]
+[target.'cfg(not(target_os = "linux"))'.dependencies]
 shared_memory = { workspace = true, features = ["logging"] }
 
+[target.'cfg(target_os = "linux")'.dependencies]
+memmap2 = { workspace = true }
+passfd = { workspace = true, features = ["async"] }
+rustix = { workspace = true, features = ["fs", "net"] }
+tokio = { workspace = true, features = ["macros", "net", "rt", "time"] }
+tokio-util = { workspace = true }
+tracing = { workspace = true }
+uuid = { workspace = true, features = ["v4"] }
+
 [dev-dependencies]
 ctor = { workspace = true }
 subprocess_test = { workspace = true }
+tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
 
 [lints]
 workspace = true

crates/fspy_shm/Cargo.toml

@@ -1,4 +1,4 @@
-//! Behavior-neutral shared-memory facade for fspy channels.
+//! Platform shared-memory implementation for fspy channels.
 //!
 //! # Ownership semantics
 //!
@@ -11,19 +11,31 @@
 //! - Already-open views remain fully usable after the owner is dropped and
 //!   keep the underlying memory alive for their own lifetime.
 //! - Once the owner is dropped, new [`open`] calls are no longer guaranteed
-//!   to succeed: they fail on POSIX platforms (the name is unlinked), while
-//!   on Windows they may still succeed as long as other handles or views keep
+//!   to succeed: they fail on Linux (the owner's broker stops serving the
+//!   mapping) and on other POSIX platforms (the name is unlinked), while on
+//!   Windows they may still succeed as long as other handles or views keep
 //!   the underlying section object alive.
 //!
 //! The fspy channel additionally gates sender creation with the receiver's
 //! lock file, so the platform difference in the last point is not observable
 //! in-protocol.
+//!
+//! On Linux the mapping is an anonymous memfd handed out by a broker task, so
+//! [`create`] must be called within a tokio runtime there.
 
+#[cfg(not(target_os = "linux"))]
 use std::io;
 
+#[cfg(target_os = "linux")]
+mod linux;
+
+#[cfg(target_os = "linux")]
+pub use linux::{Shm, create, open};
+#[cfg(not(target_os = "linux"))]
 use shared_memory::{Shmem, ShmemConf};
 
 /// An owned shared-memory mapping.
+#[cfg(not(target_os = "linux"))]
 pub struct Shm {
     inner: Shmem,
 }
@@ -37,6 +49,7 @@ pub struct Shm {
 /// # Errors
 ///
 /// Returns an error if the platform cannot create or map the region.
+#[cfg(not(target_os = "linux"))]
 pub fn create(size: usize) -> io::Result<Shm> {
     let conf = ShmemConf::new().size(size);
     #[cfg(target_os = "windows")]
@@ -55,6 +68,7 @@ pub fn create(size: usize) -> io::Result<Shm> {
 /// # Errors
 ///
 /// Returns an error if the mapping does not exist or cannot be mapped.
+#[cfg(not(target_os = "linux"))]
 pub fn open(id: &str, size: usize) -> io::Result<Shm> {
     let conf = ShmemConf::new().size(size).os_id(id);
     #[cfg(target_os = "windows")]
@@ -64,6 +78,7 @@ pub fn open(id: &str, size: usize) -> io::Result<Shm> {
     Ok(Shm { inner })
 }
 
+#[cfg(not(target_os = "linux"))]
 #[expect(clippy::len_without_is_empty, reason = "shared-memory mappings are always non-empty")]
 impl Shm {
     /// Returns this mapping's opaque platform identifier.
@@ -105,11 +120,11 @@ mod tests {
 
     use super::{Shm, create, open};
 
-    // Page-aligned on supported macOS and Windows targets.
+    // Page-aligned on all supported targets.
     const SIZE: usize = 64 * 1024;
 
-    #[test]
-    fn create_and_open_are_shared() {
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn create_and_open_are_shared() {
         let owner = create(SIZE).unwrap();
         assert_eq!(owner.len(), SIZE);
         assert_eq!(owner.as_ptr() as usize % align_of::<usize>(), 0);
@@ -126,8 +141,8 @@ mod tests {
         assert_eq!(read_byte(&owner, SIZE - 1), 29);
     }
 
-    #[test]
-    fn mapping_is_visible_across_processes() {
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn mapping_is_visible_across_processes() {
         let owner = create(SIZE).unwrap();
         write_byte(&owner, 0, 17);
 
@@ -136,21 +151,25 @@ mod tests {
             assert_eq!(read_byte(&opened, 0), 17);
             write_byte(&opened, SIZE - 1, 29);
         });
-        assert!(Command::from(command).status().unwrap().success());
+        let success =
+            tokio::task::spawn_blocking(move || Command::from(command).status().unwrap().success())
+                .await
+                .unwrap();
+        assert!(success);
         assert_eq!(read_byte(&owner, SIZE - 1), 29);
     }
 
-    #[test]
-    fn owner_drop_prevents_new_opens() {
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn owner_drop_prevents_new_opens() {
         let owner = create(SIZE).unwrap();
         let id = owner.id().to_owned();
         drop(owner);
 
         assert!(open(&id, SIZE).is_err());
     }
 
-    #[test]
-    fn opened_mapping_survives_owner_drop() {
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn opened_mapping_survives_owner_drop() {
         let owner = create(SIZE).unwrap();
         let id = owner.id().to_owned();
         let opened = open(&id, SIZE).unwrap();