use anyhow::{Context, Result};
use std::cell::RefCell;
use std::collections::{BTreeSet, HashMap, HashSet};
use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;
use std::sync::atomic::{AtomicU64, Ordering};
pub const TRACE_TOOL: &str = "strace";
const TRACE_DIR: &str = ".rsconstruct/read-trace";
const IGNORED_DIRS: &[&str] = &[".rsconstruct", ".venv", "node_modules", ".git"];
#[derive(Clone, Debug)]
pub struct Spec {
pub label: String,
pub declared: Vec<PathBuf>,
pub declared_dirs: Vec<PathBuf>,
pub writable: Vec<String>,
}
thread_local! {
static SPEC: RefCell<Option<Spec>> = const { RefCell::new(None) };
}
pub fn set_spec(spec: Option<Spec>) {
SPEC.with(|s| *s.borrow_mut() = spec);
}
pub fn spec_for(
standard: &crate::config::StandardConfig,
products: &[&crate::graph::Product],
tools: &[String],
) -> Spec {
let label = products
.first()
.map(|p| p.processor.clone())
.unwrap_or_default();
Spec {
label,
declared: products
.iter()
.flat_map(|p| p.inputs.iter().chain(&p.outputs).cloned())
.collect(),
declared_dirs: products
.iter()
.flat_map(|p| p.output_dirs.iter().map(|d| d.as_ref().clone()))
.collect(),
writable: crate::sandbox::writable_for(standard, tools),
}
}
pub fn traced_processors(
processors: &crate::processor::ProcessorMap,
active: &[&String],
build: &crate::config::BuildConfig,
) -> Vec<String> {
if build.undeclared_reads != crate::config::UndeclaredReads::Report {
return Vec::new();
}
let mut names: Vec<String> = active
.iter()
.filter(|name| processors.contains_key(name.as_str()))
.filter(|name| !crate::registries::processor::is_builtin(name))
.map(|name| (*name).clone())
.collect();
names.sort();
names
}
pub struct Trace {
pub command: Command,
log: PathBuf,
root: PathBuf,
spec: Spec,
}
pub fn prepare(cmd: &Command) -> Result<Option<Trace>> {
let Some(spec) = SPEC.with(|s| s.borrow().clone()) else {
return Ok(None);
};
let root = std::env::current_dir()
.context("Failed to determine the project root for the read trace")?;
let dir = root.join(TRACE_DIR);
fs::create_dir_all(&dir)
.with_context(|| format!("Failed to create read-trace directory {}", dir.display()))?;
static NEXT_RUN: AtomicU64 = AtomicU64::new(0);
let log = dir.join(format!(
"{}-{}.log",
std::process::id(),
NEXT_RUN.fetch_add(1, Ordering::Relaxed)
));
let mut command = Command::new(TRACE_TOOL);
command
.args(["-f", "-qq", "-z", "-y", "--kill-on-exit"])
.args(["-e", "trace=open,openat,openat2", "-e", "signal=none", "-o"])
.arg(&log)
.arg("--")
.arg(cmd.get_program())
.args(cmd.get_args());
if let Some(dir) = cmd.get_current_dir() {
command.current_dir(dir);
}
for (key, value) in cmd.get_envs() {
match value {
Some(value) => command.env(key, value),
None => command.env_remove(key),
};
}
Ok(Some(Trace {
command,
log,
root,
spec,
}))
}
impl Trace {
pub fn finish(self, tool_succeeded: bool) -> Result<()> {
let text = fs::read_to_string(&self.log)
.with_context(|| format!("Failed to read the read trace {}", self.log.display()));
let _ = fs::remove_file(&self.log);
if !tool_succeeded {
return Ok(());
}
let undeclared = undeclared_reads(&self.root, &self.spec, &text?)?;
if !undeclared.is_empty() {
let mut msg = format!(
"[{}] the tool read files its product does not declare:",
self.spec.label
);
for path in &undeclared {
msg.push_str("\n read ");
msg.push_str(&path.display().to_string());
}
crate::output::warn(&msg);
}
Ok(())
}
}
fn undeclared_reads(root: &Path, spec: &Spec, log: &str) -> Result<Vec<PathBuf>> {
let writable = spec
.writable
.iter()
.map(|entry| {
crate::sandbox::Writable::parse(entry)
.map_err(|e| anyhow::anyhow!("[{}] {e}", spec.label))
})
.collect::<Result<Vec<_>>>()?;
let declared = declared_set(root, &spec.declared);
let mut out = BTreeSet::new();
for path in read_paths(log) {
let Ok(rel) = path.strip_prefix(root) else {
continue;
};
let ignored = rel
.components()
.next()
.is_some_and(|c| IGNORED_DIRS.iter().any(|d| c.as_os_str() == *d));
if rel.as_os_str().is_empty()
|| ignored
|| declared.contains(rel)
|| spec.declared_dirs.iter().any(|d| rel.starts_with(d))
|| writable.iter().any(|w| w.covers(rel))
|| !path.is_file()
{
continue;
}
out.insert(rel.to_path_buf());
}
Ok(out.into_iter().collect())
}
fn declared_set(root: &Path, declared: &[PathBuf]) -> HashSet<PathBuf> {
let mut set = HashSet::new();
for path in declared {
let path = path.strip_prefix(".").unwrap_or(path);
let abs = root.join(path);
if fs::symlink_metadata(&abs).is_ok_and(|m| m.file_type().is_symlink())
&& let Ok(target) = fs::canonicalize(&abs)
&& let Ok(rel) = target.strip_prefix(root)
{
set.insert(rel.to_path_buf());
}
set.insert(path.to_path_buf());
}
set
}
fn read_paths(log: &str) -> Vec<PathBuf> {
let mut pending: HashMap<&str, &str> = HashMap::new();
let mut paths = Vec::new();
for line in log.lines() {
let Some((pid, call)) = line.split_once(' ') else {
continue;
};
let call = call.trim_start();
if let Some(start) = call.strip_suffix(" <unfinished ...>") {
pending.insert(pid, start);
continue;
}
let joined;
let call = if let Some(rest) = call.strip_prefix("<... ") {
let Some((_, tail)) = rest.split_once(" resumed>") else {
continue;
};
let Some(start) = pending.remove(pid) else {
continue;
};
joined = format!("{start}{tail}");
joined.as_str()
} else {
call
};
if let Some(path) = read_path(call) {
paths.push(path);
}
}
paths
}
fn read_path(call: &str) -> Option<PathBuf> {
const NOT_READS: &[&str] = &["O_WRONLY", "O_CREAT", "O_TRUNC", "O_DIRECTORY", "O_PATH"];
if !(call.starts_with("open(") || call.starts_with("openat(") || call.starts_with("openat2(")) {
return None;
}
let (args, result) = call.rsplit_once(") = ")?;
if NOT_READS.iter().any(|flag| args.contains(flag)) {
return None;
}
let path = result.split_once('<')?.1.strip_suffix('>')?;
path.starts_with('/').then(|| PathBuf::from(path))
}
#[cfg(test)]
mod tests {
use super::*;
fn spec(declared: &[&str], dirs: &[&str], writable: &[&str]) -> Spec {
Spec {
label: "processor.explicit.generic".into(),
declared: declared.iter().map(PathBuf::from).collect(),
declared_dirs: dirs.iter().map(PathBuf::from).collect(),
writable: writable.iter().map(|w| (*w).to_string()).collect(),
}
}
#[test]
fn read_path_takes_reads_and_skips_the_rest() {
assert_eq!(
read_path(r#"openat(AT_FDCWD</p>, "a.txt", O_RDONLY|O_CLOEXEC) = 3</p/a.txt>"#),
Some(PathBuf::from("/p/a.txt"))
);
assert_eq!(
read_path(r#"open("/p/b", O_RDWR) = 4</p/b>"#),
Some(PathBuf::from("/p/b"))
);
assert_eq!(
read_path(r#"openat2(AT_FDCWD</p>, "c", {flags=O_RDONLY, resolve=0}, 24) = 5</p/c>"#),
Some(PathBuf::from("/p/c"))
);
for call in [
r#"openat(AT_FDCWD</p>, "o", O_WRONLY|O_CREAT|O_TRUNC, 0666) = 3</p/o>"#,
r#"openat(AT_FDCWD</p>, "l", O_RDWR|O_CREAT, 0666) = 3</p/l>"#,
r#"openat(AT_FDCWD</p>, ".", O_RDONLY|O_DIRECTORY) = 3</p>"#,
r#"openat(AT_FDCWD</p>, "x", O_RDONLY|O_PATH) = 3</p/x>"#,
r#"stat("/p/a.txt", {st_mode=S_IFREG|0644, st_size=3, ...}) = 0"#,
] {
assert_eq!(read_path(call), None, "{call}");
}
}
#[test]
fn read_paths_joins_calls_split_by_another_process() {
let log = "\
11 openat(AT_FDCWD</p>, \"a\", O_RDONLY <unfinished ...>
12 openat(AT_FDCWD</p>, \"b\", O_RDONLY) = 3</p/b>
11 <... openat resumed>) = 4</p/a>
";
assert_eq!(
read_paths(log),
vec![PathBuf::from("/p/b"), PathBuf::from("/p/a")]
);
}
#[test]
fn only_undeclared_project_files_are_reported() {
let root = tempfile::tempdir().unwrap();
let r = root.path();
for f in [
"in.txt",
"extra.txt",
"out.txt",
"gen/x.txt",
".venv/lib/m.py",
"target/c",
"pkg/__pycache__/m.pyc",
] {
let path = r.join(f);
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(path, "x").unwrap();
}
let line = |f: &str| {
format!(
"1 openat(AT_FDCWD</>, \"{p}\", O_RDONLY) = 3<{p}>\n",
p = r.join(f).display()
)
};
let mut log: String = [
"in.txt",
"extra.txt",
"out.txt",
"gen/x.txt",
".venv/lib/m.py",
"target/c",
"pkg/__pycache__/m.pyc",
"gone.txt",
]
.iter()
.map(|f| line(f))
.collect();
log.push_str("1 openat(AT_FDCWD</>, \"/etc/hosts\", O_RDONLY) = 3</etc/hosts>\n");
let found = undeclared_reads(
r,
&spec(
&["in.txt", "out.txt"],
&["gen"],
&["target", "**/__pycache__"],
),
&log,
)
.unwrap();
assert_eq!(found, vec![PathBuf::from("extra.txt")]);
}
}