test(e2e): reproduce constrained dev shm failure

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

Author: 3 people

Cargo.lock

@@ -66,7 +66,11 @@ impl SpyImpl {
         Ok(Self { ansi_dll_path_with_nul: ansi_dll_path_with_nul.into() })
     }
 
-    #[expect(clippy::unused_async, reason = "async signature required by SpyImpl trait")]
+    #[expect(
+        clippy::unused_async,
+        clippy::unused_async_trait_impl,
+        reason = "platform implementations share an async call site"
+    )]
     pub(crate) async fn spawn(
         &self,
         mut command: Command,

crates/fspy/src/windows/mod.rs

@@ -2,7 +2,7 @@ mod test_utils;
 
 use std::{
     env::current_dir,
-    fs::{File, OpenOptions},
+    fs::{self, File, OpenOptions},
     process::Stdio,
 };
 
@@ -35,6 +35,22 @@ async fn open_write() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[test(tokio::test)]
+async fn metadata() -> anyhow::Result<()> {
+    let tmp_dir = tempfile::tempdir()?;
+    let tmp_path = tmp_dir.path().join("hello");
+    File::create(&tmp_path)?;
+    let tmp_path_str = tmp_path.to_str().unwrap().to_owned();
+
+    let accesses = track_fn!(tmp_path_str, |tmp_path_str: String| {
+        let _ = fs::metadata(tmp_path_str);
+    })
+    .await?;
+    assert_contains(&accesses, tmp_path.as_path(), AccessMode::READ);
+
+    Ok(())
+}
+
 #[test(tokio::test)]
 async fn readdir() -> anyhow::Result<()> {
     let tmpdir = tempfile::tempdir()?;

crates/fspy/tests/rust_std.rs

@@ -41,3 +41,27 @@ unsafe extern "C" fn fstatat(
     // SAFETY: calling the original libc fstatat() with the same arguments forwarded from the interposed function
     unsafe { fstatat::original()(dirfd, pathname, buf, flags) }
 }
+
+#[cfg(target_os = "linux")]
+intercept!(statx: unsafe extern "C" fn(
+    dirfd: c_int,
+    pathname: *const c_char,
+    flags: c_int,
+    mask: libc::c_uint,
+    statxbuf: *mut libc::statx,
+) -> c_int);
+#[cfg(target_os = "linux")]
+unsafe extern "C" fn statx(
+    dirfd: c_int,
+    pathname: *const c_char,
+    flags: c_int,
+    mask: libc::c_uint,
+    statxbuf: *mut libc::statx,
+) -> c_int {
+    // SAFETY: dirfd and pathname are valid arguments provided by the caller of the interposed function.
+    unsafe {
+        handle_open(PathAt(dirfd, pathname), AccessMode::READ);
+    }
+    // SAFETY: calling the original libc statx() with the same arguments forwarded from the interposed function.
+    unsafe { statx::original()(dirfd, pathname, flags, mask, statxbuf) }
+}

crates/fspy_preload_unix/src/interceptions/stat.rs

@@ -27,10 +27,11 @@ use vite_path::{AbsolutePath, AbsolutePathBuf};
 pub const POWERSHELL_PREFIX: &[&str] =
     &["-NoProfile", "-NoLogo", "-ExecutionPolicy", "Bypass", "-File"];
 
-/// Cached location of the `PowerShell` host. Prefers cross-platform
-/// `pwsh.exe` when present, falling back to the Windows built-in
-/// `powershell.exe`. Returns `None` on non-Windows or when neither host
-/// is on `PATH`.
+/// Cached location of the `PowerShell` host.
+///
+/// Prefers cross-platform `pwsh.exe` when present, falling back to the Windows
+/// built-in `powershell.exe`. Returns `None` on non-Windows or when neither
+/// host is on `PATH`.
 ///
 /// Cached as `Arc<AbsolutePath>` so callers that want shared ownership
 /// (e.g. `vite_task_plan`'s plan-time rewrite) can do `Arc::clone(host)`

crates/vite_powershell/src/lib.rs

@@ -31,6 +31,9 @@ vite_str = { workspace = true }
 vite_task = { workspace = true }
 which = { workspace = true }
 
+[target.'cfg(target_os = "linux")'.dependencies]
+nix = { workspace = true, features = ["mount", "sched", "user"] }
+
 [dev-dependencies]
 cow-utils = { workspace = true }
 cp_r = { workspace = true }

crates/vite_task_bin/Cargo.toml

@@ -23,7 +23,16 @@ mod print_file;
 mod read_stdin;
 mod replace_file_content;
 mod rm;
+#[cfg(target_os = "linux")]
+mod small_dev_shm;
+#[cfg(not(target_os = "linux"))]
+mod small_dev_shm {
+    pub fn run(_args: &[String]) -> anyhow::Result<()> {
+        anyhow::bail!("vtt small_dev_shm is only supported on Linux")
+    }
+}
 mod stat_file;
+mod stat_long_filename;
 mod touch_file;
 mod write_file;
 
@@ -32,7 +41,7 @@ fn main() {
     if args.len() < 2 {
         eprintln!("Usage: vtt <subcommand> [args...]");
         eprintln!(
-            "Subcommands: barrier, check-tty, cp, exit, exit-on-ctrlc, grep-file, list-dir, mkdir, pipe-stdin, print, print-color, print-cwd, print-env, print-file, read-stdin, replace-file-content, rm, stat-file, touch-file, write-file"
+            "Subcommands: barrier, check-tty, cp, exit, exit-on-ctrlc, grep-file, list-dir, mkdir, pipe-stdin, print, print-color, print-cwd, print-env, print-file, read-stdin, replace-file-content, rm, small_dev_shm, stat-file, stat_long_filename, touch-file, write-file"
         );
         std::process::exit(1);
     }
@@ -64,10 +73,12 @@ fn main() {
         "read-stdin" => read_stdin::run(),
         "replace-file-content" => replace_file_content::run(&args[2..]),
         "rm" => rm::run(&args[2..]),
+        "small_dev_shm" => small_dev_shm::run(&args[2..]).map_err(Into::into),
         "stat-file" => {
             stat_file::run(&args[2..]);
             Ok(())
         }
+        "stat_long_filename" => stat_long_filename::run(&args[2..]),
         "touch-file" => touch_file::run(&args[2..]),
         "write-file" => write_file::run(&args[2..]),
         other => {

crates/vite_task_bin/src/vtt/main.rs

@@ -0,0 +1,58 @@
+#![cfg(target_os = "linux")]
+
+use std::{os::unix::process::ExitStatusExt as _, process::Command};
+
+use anyhow::{Context as _, Result};
+use nix::{
+    mount::{MsFlags, mount},
+    sched::{CloneFlags, unshare},
+    unistd::{Gid, Uid},
+};
+
+const USAGE: &str = "Usage: vtt small_dev_shm <command> [args...]";
+
+pub fn run(args: &[String]) -> Result<()> {
+    let (program, command_args) = parse_command(args)?;
+    run_platform(program, command_args)
+}
+
+fn parse_command(args: &[String]) -> Result<(&str, &[String])> {
+    args.split_first().map(|(program, args)| (program.as_str(), args)).context(USAGE)
+}
+
+fn run_platform(program: &str, command_args: &[String]) -> Result<()> {
+    let uid = Uid::current().as_raw();
+    let gid = Gid::current().as_raw();
+
+    unshare(CloneFlags::CLONE_NEWUSER | CloneFlags::CLONE_NEWNS)
+        .context("unshare user and mount namespaces")?;
+
+    std::fs::write("/proc/self/uid_map", format!("0 {uid} 1\n"))
+        .context("write /proc/self/uid_map")?;
+    match std::fs::write("/proc/self/setgroups", "deny") {
+        Ok(()) => {}
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
+        Err(error) => return Err(error).context("write /proc/self/setgroups"),
+    }
+    std::fs::write("/proc/self/gid_map", format!("0 {gid} 1\n"))
+        .context("write /proc/self/gid_map")?;
+
+    mount(None::<&str>, "/", None::<&str>, MsFlags::MS_REC | MsFlags::MS_PRIVATE, None::<&str>)
+        .context("make / recursively private")?;
+
+    mount(
+        Some("tmpfs"),
+        "/dev/shm",
+        Some("tmpfs"),
+        MsFlags::empty(),
+        Some("nr_blocks=1,huge=never"),
+    )
+    .context("mount one-page tmpfs at /dev/shm")?;
+
+    let status = Command::new(program)
+        .args(command_args)
+        .status()
+        .context("run command with constrained /dev/shm")?;
+    let code = status.code().unwrap_or_else(|| status.signal().map_or(1, |signal| 128 + signal));
+    std::process::exit(code);
+}

crates/vite_task_bin/src/vtt/small_dev_shm.rs

@@ -0,0 +1,39 @@
+use std::{error::Error, io};
+
+const USAGE: &str = "Usage: vtt stat_long_filename <count>";
+
+pub fn run(args: &[String]) -> Result<(), Box<dyn Error>> {
+    let count = parse_count(args)?;
+    access_generated_path(count, metadata)?;
+    Ok(())
+}
+
+fn parse_count(args: &[String]) -> Result<usize, String> {
+    let [count] = args else { return Err(USAGE.to_owned()) };
+    count.parse().map_err(|_| USAGE.to_owned())
+}
+
+fn generated_path(count: usize) -> String {
+    "x".repeat(count)
+}
+
+fn access_generated_path(
+    count: usize,
+    mut metadata: impl FnMut(&str) -> io::Result<()>,
+) -> io::Result<()> {
+    let path = generated_path(count);
+    match metadata(&path) {
+        Ok(()) => Ok(()),
+        Err(error)
+            if error.kind() == io::ErrorKind::NotFound
+                || error.raw_os_error() == Some(libc::ENAMETOOLONG) =>
+        {
+            Ok(())
+        }
+        Err(error) => Err(error),
+    }
+}
+
+fn metadata(path: &str) -> io::Result<()> {
+    std::fs::metadata(path).map(|_| ())
+}

crates/vite_task_bin/src/vtt/stat_long_filename.rs

@@ -0,0 +1 @@
+{}