test(e2e): reproduce constrained dev shm failure

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

Author: wan9chi

Cargo.lock

@@ -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,6 +23,7 @@ mod print_file;
 mod read_stdin;
 mod replace_file_content;
 mod rm;
+mod small_dev_shm;
 mod stat_file;
 mod touch_file;
 mod write_file;
@@ -32,7 +33,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, touch-file, write-file"
         );
         std::process::exit(1);
     }
@@ -64,10 +65,8 @@ fn main() {
         "read-stdin" => read_stdin::run(),
         "replace-file-content" => replace_file_content::run(&args[2..]),
         "rm" => rm::run(&args[2..]),
-        "stat-file" => {
-            stat_file::run(&args[2..]);
-            Ok(())
-        }
+        "small_dev_shm" => small_dev_shm::run(&args[2..]),
+        "stat-file" => stat_file::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,116 @@
+use std::error::Error;
+
+const USAGE: &str = "Usage: vtt small_dev_shm <command> [args...]";
+
+pub fn run(args: &[String]) -> Result<(), Box<dyn Error>> {
+    let (program, command_args) = parse_command(args)?;
+    run_platform(program, command_args)?;
+    Ok(())
+}
+
+fn parse_command(args: &[String]) -> Result<(&str, &[String]), &'static str> {
+    args.split_first().map(|(program, args)| (program.as_str(), args)).ok_or(USAGE)
+}
+
+#[cfg(target_os = "linux")]
+fn write_procfs(path: &str, content: &str) -> std::io::Result<()> {
+    use std::io::Write as _;
+
+    let mut file = std::fs::OpenOptions::new().write(true).open(path)?;
+    file.write_all(content.as_bytes())
+}
+
+#[cfg(target_os = "linux")]
+fn run_platform(program: &str, command_args: &[String]) -> std::io::Result<()> {
+    use std::{os::unix::process::ExitStatusExt as _, process::Command};
+
+    use nix::{
+        mount::{MsFlags, mount},
+        sched::{CloneFlags, unshare},
+        unistd::{Gid, Uid},
+    };
+
+    fn operation_error(operation: &str, error: impl std::fmt::Display) -> std::io::Error {
+        std::io::Error::other(format!("{operation}: {error}"))
+    }
+
+    let uid = Uid::current().as_raw();
+    let gid = Gid::current().as_raw();
+
+    unshare(CloneFlags::CLONE_NEWUSER | CloneFlags::CLONE_NEWNS)
+        .map_err(|error| operation_error("unshare user and mount namespaces", error))?;
+
+    write_procfs("/proc/self/uid_map", &format!("0 {uid} 1\n"))
+        .map_err(|error| operation_error("write /proc/self/uid_map", error))?;
+    match write_procfs("/proc/self/setgroups", "deny") {
+        Ok(()) => {}
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
+        Err(error) => return Err(operation_error("write /proc/self/setgroups", error)),
+    }
+    write_procfs("/proc/self/gid_map", &format!("0 {gid} 1\n"))
+        .map_err(|error| operation_error("write /proc/self/gid_map", error))?;
+
+    mount(None::<&str>, "/", None::<&str>, MsFlags::MS_REC | MsFlags::MS_PRIVATE, None::<&str>)
+        .map_err(|error| operation_error("make / recursively private", error))?;
+
+    mount(
+        Some("tmpfs"),
+        "/dev/shm",
+        Some("tmpfs"),
+        MsFlags::empty(),
+        Some("nr_blocks=1,huge=never"),
+    )
+    .map_err(|error| operation_error("mount one-page tmpfs at /dev/shm", error))?;
+
+    let status = Command::new(program).args(command_args).status()?;
+    let code = status.code().unwrap_or_else(|| status.signal().map_or(1, |signal| 128 + signal));
+    std::process::exit(code);
+}
+
+#[cfg(not(target_os = "linux"))]
+fn run_platform(_program: &str, _command_args: &[String]) -> std::io::Result<()> {
+    Err(std::io::Error::new(
+        std::io::ErrorKind::Unsupported,
+        "vtt small_dev_shm is only supported on Linux",
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn requires_a_command() {
+        assert_eq!(parse_command(&[]).unwrap_err(), USAGE);
+    }
+
+    #[test]
+    fn parses_command_and_arguments() {
+        let args = ["vt".to_owned(), "run".to_owned(), "stress".to_owned()];
+        let (program, command_args) = parse_command(&args).unwrap();
+
+        assert_eq!(program, "vt");
+        assert_eq!(command_args, ["run", "stress"]);
+    }
+
+    #[cfg(target_os = "linux")]
+    #[test]
+    fn procfs_writer_does_not_create_missing_files() {
+        let tempdir = tempfile::tempdir().unwrap();
+        let missing = tempdir.path().join("missing");
+
+        let error = write_procfs(missing.to_str().unwrap(), "content").unwrap_err();
+
+        assert_eq!(error.kind(), std::io::ErrorKind::NotFound);
+        assert!(!missing.exists());
+    }
+
+    #[cfg(not(target_os = "linux"))]
+    #[test]
+    fn reports_unsupported_platform() {
+        let error = run_platform("vt", &[]).unwrap_err();
+
+        assert_eq!(error.kind(), std::io::ErrorKind::Unsupported);
+        assert_eq!(error.to_string(), "vtt small_dev_shm is only supported on Linux");
+    }
+}

crates/vite_task_bin/src/vtt/small_dev_shm.rs

@@ -1,9 +1,200 @@
-pub fn run(args: &[String]) {
-    for file in args {
-        if std::fs::metadata(file).is_ok() {
-            println!("{file}: exists");
-        } else {
-            println!("{file}: missing");
+use std::{error::Error, io};
+
+const USAGE: &str = "Usage: vtt stat-file [--generated-path-bytes <count>] [--quiet] [<path>...]";
+
+#[derive(Debug, PartialEq)]
+struct Options<'a> {
+    generated_path_bytes: Option<usize>,
+    quiet: bool,
+    paths: Vec<&'a str>,
+}
+
+pub fn run(args: &[String]) -> Result<(), Box<dyn Error>> {
+    let options = parse_args(args)?;
+    run_with(&options, metadata, |path, exists| {
+        println!("{path}: {}", if exists { "exists" } else { "missing" })
+    });
+    Ok(())
+}
+
+#[cfg(target_os = "linux")]
+fn metadata(path: &str) -> io::Result<()> {
+    use std::{ffi::CString, mem::MaybeUninit};
+
+    let path = CString::new(path)
+        .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "path contains NUL"))?;
+    let mut statx = MaybeUninit::<libc::statx>::uninit();
+    // SAFETY: `path` is NUL-terminated, `statx` points to writable storage,
+    // and the final zero is an ignored sixth syscall argument supplied so
+    // fspy's variadic syscall interceptor can read a complete argument set.
+    let result = unsafe {
+        libc::syscall(
+            libc::SYS_statx,
+            libc::AT_FDCWD,
+            path.as_ptr(),
+            0,
+            libc::STATX_BASIC_STATS,
+            statx.as_mut_ptr(),
+            0,
+        )
+    };
+    if result == -1 { Err(io::Error::last_os_error()) } else { Ok(()) }
+}
+
+#[cfg(not(target_os = "linux"))]
+fn metadata(path: &str) -> io::Result<()> {
+    std::fs::metadata(path).map(|_| ())
+}
+
+fn parse_args(args: &[String]) -> Result<Options<'_>, String> {
+    let mut generated_path_bytes = None;
+    let mut quiet = false;
+    let mut paths = Vec::new();
+    let mut args = args.iter();
+
+    while let Some(arg) = args.next() {
+        match arg.as_str() {
+            "--generated-path-bytes" => {
+                if generated_path_bytes.is_some() {
+                    return Err(format!(
+                        "{USAGE}\n--generated-path-bytes may only be specified once"
+                    ));
+                }
+                let count = args
+                    .next()
+                    .ok_or_else(|| format!("{USAGE}\n--generated-path-bytes requires a count"))?;
+                generated_path_bytes =
+                    Some(count.parse::<usize>().map_err(|_| {
+                        format!("{USAGE}\ninvalid generated path byte count: {count}")
+                    })?);
+            }
+            "--quiet" => quiet = true,
+            path => paths.push(path),
+        }
+    }
+
+    if generated_path_bytes.is_some() && !paths.is_empty() {
+        return Err(format!("{USAGE}\n--generated-path-bytes cannot be used with explicit paths"));
+    }
+
+    Ok(Options { generated_path_bytes, quiet, paths })
+}
+
+fn run_with(
+    options: &Options<'_>,
+    mut metadata: impl FnMut(&str) -> io::Result<()>,
+    mut report: impl FnMut(&str, bool),
+) {
+    if let Some(byte_count) = options.generated_path_bytes {
+        let path = "x".repeat(byte_count);
+        let exists = metadata(&path).is_ok();
+        if !options.quiet {
+            report(&path, exists);
+        }
+        return;
+    }
+
+    for path in &options.paths {
+        let exists = metadata(path).is_ok();
+        if !options.quiet {
+            report(path, exists);
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn strings(args: &[&str]) -> Vec<String> {
+        args.iter().map(|arg| (*arg).to_owned()).collect()
+    }
+
+    #[test]
+    fn parses_generated_path_and_quiet() {
+        let args = strings(&["--generated-path-bytes", "1048576", "--quiet"]);
+
+        assert_eq!(
+            parse_args(&args).unwrap(),
+            Options { generated_path_bytes: Some(1_048_576), quiet: true, paths: vec![] }
+        );
+    }
+
+    #[test]
+    fn preserves_explicit_path_behavior() {
+        let args = strings(&["present", "missing"]);
+
+        assert_eq!(
+            parse_args(&args).unwrap(),
+            Options { generated_path_bytes: None, quiet: false, paths: vec!["present", "missing"] }
+        );
+    }
+
+    #[test]
+    fn rejects_generated_path_with_explicit_paths() {
+        let args = strings(&["--generated-path-bytes", "12", "explicit"]);
+
+        assert!(parse_args(&args).unwrap_err().contains("cannot be used with explicit paths"));
+    }
+
+    #[test]
+    fn rejects_missing_or_invalid_generated_path_count() {
+        let missing = strings(&["--generated-path-bytes"]);
+        let invalid = strings(&["--generated-path-bytes", "many"]);
+
+        assert!(parse_args(&missing).unwrap_err().contains("requires a count"));
+        assert!(parse_args(&invalid).unwrap_err().contains("invalid generated path byte count"));
+    }
+
+    #[test]
+    fn generated_mode_stats_one_exact_non_nul_ascii_path() {
+        let options = Options { generated_path_bytes: Some(4096), quiet: false, paths: vec![] };
+        let mut calls = 0;
+        let mut generated_path = String::new();
+        let mut reports = 0;
+
+        run_with(
+            &options,
+            |path| {
+                calls += 1;
+                generated_path = path.to_owned();
+                Err(io::Error::from_raw_os_error(libc::ENAMETOOLONG))
+            },
+            |_, _| reports += 1,
+        );
+
+        assert_eq!(calls, 1);
+        assert_eq!(generated_path.len(), 4096);
+        assert!(generated_path.is_ascii());
+        assert!(!generated_path.as_bytes().contains(&0));
+        assert_eq!(reports, 1);
+    }
+
+    #[test]
+    fn generated_mode_treats_missing_as_success() {
+        let options = Options { generated_path_bytes: Some(8), quiet: false, paths: vec![] };
+        let mut missing = None;
+
+        run_with(
+            &options,
+            |_| Err(io::Error::from(io::ErrorKind::NotFound)),
+            |_, exists| missing = Some(!exists),
+        );
+
+        assert_eq!(missing, Some(true));
+    }
+
+    #[test]
+    fn quiet_suppresses_output() {
+        let options = Options { generated_path_bytes: Some(8), quiet: true, paths: vec![] };
+        let mut output = Vec::new();
+
+        run_with(
+            &options,
+            |_| Err(io::Error::from(io::ErrorKind::NotFound)),
+            |path, exists| output.push((path.to_owned(), exists)),
+        );
+
+        assert!(output.is_empty());
+    }
+}

crates/vite_task_bin/src/vtt/stat_file.rs

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

crates/vite_task_bin/tests/e2e_snapshots/fixtures/constrained_dev_shm/package.json

@@ -0,0 +1,4 @@
+[[e2e]]
+name = "constrained_dev_shm"
+platform = "linux-gnu"
+steps = [["vtt", "small_dev_shm", "vt", "run", "stress"]]

crates/vite_task_bin/tests/e2e_snapshots/fixtures/constrained_dev_shm/snapshots.toml

@@ -0,0 +1,9 @@
+# constrained_dev_shm
+
+## `vtt small_dev_shm vt run stress`
+
+**Exit code:** 135
+
+```
+$ vtt stat-file --generated-path-bytes 1048576 --quiet
+```

crates/vite_task_bin/tests/e2e_snapshots/fixtures/constrained_dev_shm/snapshots/constrained_dev_shm.md

@@ -0,0 +1,8 @@
+{
+  "tasks": {
+    "stress": {
+      "command": "vtt stat-file --generated-path-bytes 1048576 --quiet",
+      "cache": true
+    }
+  }
+}