Stat tracked files relative to their directories (refs #41) e96a430c78f3

 "libc",

[target.'cfg(unix)'.dependencies]

libc = "0.2"

                let e = self.file_entry(rel, &path, &walk::Stat::of(&meta), cache)?;

        meta: &walk::Stat,

pub(crate) fn is_executable(m: &fs::Metadata) -> bool {

pub(crate) fn is_executable(_m: &fs::Metadata) -> bool {

    meta: &walk::Stat,

    let racy = meta.mtime_ns + 2_000_000_000 >= m.written_ns;

    (e.size == meta.size && e.mtime_ns == meta.mtime_ns && !racy).then_some(e)

    meta: &walk::Stat,

    let exec = meta.exec;

    let stat = Some((meta.size, meta.mtime_ns));

/// A tracked path as it is now: a file's stat, or a symlink's target.

enum Tracked {

    File(super::walk::Stat),

    Link(Vec<u8>),

}

/// The stat of every path in `rels` (relative to `root`; `None` for one

/// gone or neither a file nor a symlink), in the same order. Paths are

/// grouped by directory and each directory is opened once: a stat relative

/// to it resolves one name, where a stat by full path walks every

/// component from the root again (most of a clean status's time, in the

/// kernel's path lookup, on the Linux tree).

fn stat_tracked(root: &Path, rels: &[&String]) -> Vec<Option<Tracked>> {

    use rayon::prelude::*;

    let mut by_dir: HashMap<&str, Vec<(usize, &str)>> = HashMap::new();

    for (i, rel) in rels.iter().enumerate() {

        let (dir, name) = rel.rsplit_once('/').unwrap_or(("", rel.as_str()));

        by_dir.entry(dir).or_default().push((i, name));

    }

    let groups: Vec<(&str, Vec<(usize, &str)>)> = by_dir.into_iter().collect();

    let found: Vec<(usize, Option<Tracked>)> = groups

        .par_iter()

        .flat_map_iter(|(dir, names)| {

            let handle = fs::File::open(root.join(dir)).ok();

            names

                .iter()

                .map(|(i, name)| {

                    let rel = rels[*i];

                    let now = match &handle {

                        Some(d) => stat_in(d, name, || root.join(rel)),

                        None => None,

                    };

                    (*i, now)

                })

                .collect::<Vec<_>>()

        })

        .collect();

    let mut out: Vec<Option<Tracked>> = (0..rels.len()).map(|_| None).collect();

    for (i, now) in found {

        out[i] = now;

    }

    out

}

/// One entry of the open directory `dir`; `path` builds its full path,

/// needed only for a symlink's target.

#[cfg(unix)]

fn stat_in(dir: &fs::File, name: &str, path: impl Fn() -> PathBuf) -> Option<Tracked> {

    use std::os::fd::AsRawFd;

    let c = std::ffi::CString::new(name).ok()?;

    let mut st: libc::stat = unsafe { std::mem::zeroed() };

    // SAFETY: a valid directory descriptor, a NUL-terminated name, and a

    // stat buffer of the right type that outlives the call.

    let r = unsafe {

        libc::fstatat(

            dir.as_raw_fd(),

            c.as_ptr(),

            &mut st,

            libc::AT_SYMLINK_NOFOLLOW,

        )

    };

    if r != 0 {

        return None;

    }

    match st.st_mode & libc::S_IFMT {

        libc::S_IFREG => Some(Tracked::File(super::walk::Stat {

            size: st.st_size as u64,

            // As `mtime_ns` reads it: nanoseconds since the epoch, 0 before it.

            mtime_ns: if st.st_mtime < 0 {

                0

            } else {

                st.st_mtime as u128 * 1_000_000_000 + st.st_mtime_nsec as u128

            },

            exec: st.st_mode & 0o111 != 0,

        })),

        libc::S_IFLNK => {

            let t = fs::read_link(path()).ok()?;

            Some(Tracked::Link(t.to_string_lossy().as_bytes().to_vec()))

        }

        _ => None,

    }

}

#[cfg(not(unix))]

fn stat_in(_dir: &fs::File, _name: &str, path: impl Fn() -> PathBuf) -> Option<Tracked> {

    let p = path();

    let m = fs::symlink_metadata(&p).ok()?;

    if m.file_type().is_symlink() {

        let t = fs::read_link(&p).ok()?;

        Some(Tracked::Link(t.to_string_lossy().as_bytes().to_vec()))

    } else if m.is_file() {

        Some(Tracked::File(super::walk::Stat::of(&m)))

    } else {

        None

    }

}

        let rels: Vec<&String> = manifest.entries.keys().collect();

        let now = stat_tracked(root, &rels);

        let differs_from = |me: &ManifestEntry, rel: &str, now: &Tracked| match now {

            Tracked::Link(t) => *blake3::hash(t).as_bytes() != me.hash,

            Tracked::File(m) => {

                m.size != me.size

                    || m.exec != me.exec

                    || (m.mtime_ns != me.mtime_ns

                        && !fs::read(root.join(rel))

                            .is_ok_and(|b| *blake3::hash(&b).as_bytes() == me.hash))

        // A path gone or no longer a file: its directory moved, unless

        // within a clock tick; list the tree to be sure.

        if now.iter().any(Option::is_none) {

            return None;

        }

        // The entries in the order `rels` was taken in: no lookup by path.

        let entries: Vec<&ManifestEntry> = manifest.entries.values().collect();

        let differs = rels

            .par_iter()

            .zip(entries.par_iter())

            .zip(now.par_iter())

            .any(|((rel, me), n)| differs_from(me, rel, n.as_ref().unwrap()));

        if keep && (differs || racy) {

            let mut listing = super::walk::Listing {

                dirs: manifest.dirs.clone(),

                nested: manifest.nested.iter().map(|n| root.join(n)).collect(),

                ..Default::default()

            };

            for (rel, n) in rels.into_iter().zip(now) {

                match n.unwrap() {

                    Tracked::File(m) => listing.files.push((rel.clone(), root.join(rel), m)),

                    Tracked::Link(t) => listing.symlinks.push((rel.clone(), t)),

            *self.listing_cache.borrow_mut() = Some(listing);

        }

                    m.size != me.size

                        || m.exec != me.exec

                        || (m.mtime_ns != me.mtime_ns

/// What a stat says about a file that the working copy needs: its size,

/// modification time and executable bit.

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub(crate) struct Stat {

    pub size: u64,

    pub mtime_ns: u128,

    pub exec: bool,

}

impl Stat {

    pub(crate) fn of(m: &fs::Metadata) -> Stat {

        Stat {

            size: m.len(),

            mtime_ns: super::prompt::mtime_ns(m),

            exec: super::is_executable(m),

        }

    }

}

    pub files: Vec<(String, PathBuf, Stat)>,

                Ok(m) => mine.files.push((child, path, Stat::of(&m))),

Then the stat check by directory (same night): tracked files are grouped

by directory, each directory opened once, and each file statted relative

to it (`fstatat`), so a stat resolves one name rather than every component

from the root (the kernel's path lookup was most of a clean status). The

stat check went from 84 ms to 73 ms; a clean status is 0.10 to 0.12 s,

level with tuned Git (0.10 to 0.11 s). What is left is the 96 000 stat

calls themselves, the same work Git does; doing less needs a file watcher

(Git's fsmonitor), which oxy does not have.