Return file creation times on Linux (using statx)

cap-primitives/src/fs/metadata.rs

@@ -48,35 +48,13 @@ impl Metadata {
 
     #[inline]
     fn from_parts(std: fs::Metadata, ext: MetadataExt, file_type: FileType) -> Self {
-        // TODO: Initialize `created` on Linux with `std.created().ok()` once we
-        // make use of `statx`.
         Self {
             file_type,
             len: std.len(),
             permissions: Permissions::from_std(std.permissions()),
             modified: std.modified().ok().map(SystemTime::from_std),
             accessed: std.accessed().ok().map(SystemTime::from_std),
-
-            #[cfg(any(
-                target_os = "freebsd",
-                target_os = "openbsd",
-                target_os = "macos",
-                target_os = "ios",
-                target_os = "netbsd",
-                windows,
-            ))]
             created: std.created().ok().map(SystemTime::from_std),
-
-            #[cfg(not(any(
-                target_os = "freebsd",
-                target_os = "openbsd",
-                target_os = "macos",
-                target_os = "ios",
-                target_os = "netbsd",
-                windows,
-            )))]
-            created: None,
-
             ext,
         }
     }

cap-primitives/src/rustix/fs/metadata_ext.rs

@@ -3,6 +3,9 @@
 use crate::fs::PermissionsExt;
 use crate::fs::{FileTypeExt, Metadata};
 use crate::time::{Duration, SystemClock, SystemTime};
+// TODO: update all these to
+// #[cfg(any(target_os = "android", target_os = "linux"))]
+// once we're on restix >= v0.34.3.
 #[cfg(all(target_os = "linux", target_env = "gnu"))]
 use rustix::fs::{makedev, Statx};
 use rustix::fs::{RawMode, Stat};
@@ -222,7 +225,6 @@ impl MetadataExt {
     /// Constructs a new instance of `Metadata` from the given `Statx`.
     #[cfg(all(target_os = "linux", target_env = "gnu"))]
     #[inline]
-    #[allow(dead_code)] // TODO: use `statx` when possible.
     pub(crate) fn from_rustix_statx(statx: Statx) -> Metadata {
         Metadata {
             file_type: FileTypeExt::from_raw_mode(RawMode::from(statx.stx_mode)),

cap-primitives/src/rustix/fs/stat_unchecked.rs

@@ -3,6 +3,14 @@ use rustix::fs::{statat, AtFlags};
 use std::path::Path;
 use std::{fs, io};
 
+// TODO: update all these to
+// #[cfg(any(target_os = "android", target_os = "linux"))]
+// once we're on restix >= v0.34.3.
+#[cfg(all(target_os = "linux", target_env = "gnu"))]
+use rustix::fs::{statx, StatxFlags};
+#[cfg(all(target_os = "linux", target_env = "gnu"))]
+use std::sync::atomic::{AtomicBool, Ordering};
+
 /// *Unsandboxed* function similar to `stat`, but which does not perform
 /// sandboxing.
 pub(crate) fn stat_unchecked(
@@ -15,5 +23,26 @@ pub(crate) fn stat_unchecked(
         FollowSymlinks::No => AtFlags::SYMLINK_NOFOLLOW,
     };
 
+    // `statx` is preferred on Linux because it can return creation times. Linux
+    // kernels prior to 4.11 don't have `statx` and return `ENOSYS`. We store the
+    // availability in a global to avoid unnecessary syscalls.
+    #[cfg(all(target_os = "linux", target_env = "gnu"))]
+    static HAS_STATX: AtomicBool = AtomicBool::new(true);
+
+    #[cfg(all(target_os = "linux", target_env = "gnu"))]
+    if HAS_STATX.load(Ordering::Relaxed) {
+        let statx_result = statx(
+            start,
+            path,
+            atflags,
+            StatxFlags::BASIC_STATS | StatxFlags::BTIME,
+        );
+        if let Err(rustix::io::Error::NOSYS) = statx_result {
+            HAS_STATX.store(false, Ordering::Relaxed);
+        } else {
+            return Ok(statx_result.map(MetadataExt::from_rustix_statx)?);
+        }
+    }
+
     Ok(statat(start, path, atflags).map(MetadataExt::from_rustix)?)
 }

tests/metadata-ext.rs

@@ -83,3 +83,55 @@ fn test_metadata_ext() {
         );
     }
 }
+
+#[test]
+fn test_metadata_ext_created() {
+    let tmpdir = tmpdir();
+    let a = check!(tmpdir.create("a"));
+    let a_metadata = check!(a.metadata());
+
+    let modified = check!(a_metadata.modified());
+    let tolerance = std::time::Duration::from_secs(10);
+    let expected = (modified - tolerance)..(modified + tolerance);
+
+    // If the standard library supports file creation times, then cap-std
+    // should too.
+    let std_supports_created = matches!(
+        a.into_std().metadata(),
+        Ok(m) if m.created().is_ok(),
+    );
+
+    if std_supports_created {
+        let created = check!(a_metadata.created());
+        assert!(
+            expected.contains(&created),
+            "expected File creation time near {:#?} but got {:#?}",
+            modified,
+            created,
+        );
+
+        let tmpdir_metadata = check!(tmpdir.dir_metadata());
+        let created = check!(tmpdir_metadata.created());
+        assert!(
+            expected.contains(&created),
+            "expected Dir creation time near {:#?} but got {:#?}",
+            modified,
+            created,
+        );
+
+        let mut entries = check!(tmpdir.entries());
+        if let Some(a) = entries.next() {
+            let a = check!(a);
+            assert_eq!(a.file_name(), "a");
+            let metadata = check!(a.metadata());
+            let created = check!(metadata.created());
+            assert!(
+                expected.contains(&created),
+                "expected DirEntry creation time near {:#?} but got {:#?}",
+                modified,
+                created,
+            );
+        }
+        assert!(entries.next().is_none(), "unexpected dir entry");
+    }
+}