wasmtime 36.0.0 → 36.0.1

data/ext/cargo-vendor/wasmtime-wasi-36.0.19/src/filesystem/primitives/rustix/fs/create_dir_unchecked.rs

@@ -0,0 +1,19 @@
+use crate::filesystem::primitives::DirOptions;
+use rustix::fs::{Mode, RawMode, mkdirat};
+use std::path::Path;
+use std::{fs, io};
+
+/// *Unsandboxed* function similar to `create_dir`, but which does not perform
+/// sandboxing.
+pub(crate) fn create_dir_unchecked(
+    start: &fs::File,
+    path: &Path,
+    options: &DirOptions,
+) -> io::Result<()> {
+    #[cfg(not(target_os = "wasi"))]
+    let raw_mode = options.ext.mode as RawMode;
+    #[cfg(target_os = "wasi")]
+    let raw_mode = 0;
+
+    Ok(mkdirat(start, path, Mode::from_bits(raw_mode).unwrap())?)
+}

data/ext/cargo-vendor/wasmtime-wasi-36.0.19/src/filesystem/primitives/rustix/fs/cvt.rs

@@ -0,0 +1,19 @@
+use std::io;
+
+#[allow(dead_code)]
+pub(crate) fn cvt_i32(t: i32) -> io::Result<i32> {
+    if t == -1 {
+        Err(io::Error::last_os_error())
+    } else {
+        Ok(t)
+    }
+}
+
+#[allow(dead_code)]
+pub(crate) fn cvt_i64(t: i64) -> io::Result<i64> {
+    if t == -1 {
+        Err(io::Error::last_os_error())
+    } else {
+        Ok(t)
+    }
+}

data/ext/cargo-vendor/wasmtime-wasi-36.0.19/src/filesystem/primitives/rustix/fs/dir_entry_inner.rs

@@ -0,0 +1,41 @@
+use crate::filesystem::primitives::{Metadata, ReadDirInner};
+use rustix::fs::DirEntry;
+use std::ffi::{OsStr, OsString};
+#[cfg(unix)]
+use std::os::unix::ffi::OsStrExt;
+#[cfg(target_os = "wasi")]
+use std::os::wasi::ffi::OsStrExt;
+use std::{fmt, io};
+
+pub(crate) struct DirEntryInner {
+    pub(super) rustix: DirEntry,
+    pub(super) read_dir: ReadDirInner,
+}
+
+impl DirEntryInner {
+    #[inline]
+    pub(crate) fn metadata(&self) -> io::Result<Metadata> {
+        self.read_dir.metadata(self.file_name_bytes())
+    }
+
+    #[inline]
+    pub(crate) fn file_name(&self) -> OsString {
+        self.file_name_bytes().to_os_string()
+    }
+
+    #[inline]
+    pub(crate) fn ino(&self) -> u64 {
+        self.rustix.ino()
+    }
+
+    fn file_name_bytes(&self) -> &OsStr {
+        OsStr::from_bytes(self.rustix.file_name().to_bytes())
+    }
+}
+
+impl fmt::Debug for DirEntryInner {
+    // Like libstd's version, but doesn't print the path.
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("DirEntry").field(&self.file_name()).finish()
+    }
+}

data/ext/cargo-vendor/wasmtime-wasi-36.0.19/src/filesystem/primitives/rustix/fs/dir_options_ext.rs

@@ -0,0 +1,14 @@
+#[derive(Debug, Clone)]
+pub(crate) struct DirOptionsExt {
+    pub(super) mode: u32,
+}
+
+impl DirOptionsExt {
+    pub(crate) const fn new() -> Self {
+        Self {
+            // The default value; see
+            // <https://doc.rust-lang.org/std/os/unix/fs/trait.DirBuilderExt.html#tymethod.mode>
+            mode: 0o777,
+        }
+    }
+}

data/ext/cargo-vendor/wasmtime-wasi-36.0.19/src/filesystem/primitives/rustix/fs/dir_utils.rs

@@ -0,0 +1,198 @@
+use crate::filesystem::primitives::OpenOptions;
+use rustix::fs::OFlags;
+use std::ffi::OsStr;
+use std::ops::Deref;
+#[cfg(unix)]
+use std::os::unix::{ffi::OsStrExt, fs::OpenOptionsExt};
+#[cfg(target_os = "wasi")]
+use std::os::wasi::{ffi::OsStrExt, fs::OpenOptionsExt};
+use std::path::Path;
+use std::{fs, io};
+
+/// Rust's `Path` implicitly strips redundant slashes, however they aren't
+/// redundant in one case: at the end of a path they indicate that a path is
+/// expected to name a directory.
+pub(crate) fn path_requires_dir(path: &Path) -> bool {
+    let bytes = path.as_os_str().as_bytes();
+
+    // If a path ends with '/' or '.', it's a directory. These aren't the only
+    // cases, but they are the only cases that Rust's `Path` implicitly
+    // normalizes away.
+    bytes.ends_with(b"/") || bytes.ends_with(b"/.")
+}
+
+/// Rust's `Path` implicitly strips trailing `.` components, however they
+/// aren't redundant in one case: at the end of a path they are the final path
+/// component, which has different path lookup behavior.
+pub(crate) fn path_has_trailing_dot(path: &Path) -> bool {
+    let mut bytes = path.as_os_str().as_bytes();
+
+    // If a path ends with '.' followed by any number of '/'s, it's a trailing dot.
+    while let Some((last, rest)) = bytes.split_last() {
+        if *last == b'/' {
+            bytes = rest;
+        } else {
+            break;
+        }
+    }
+
+    bytes.ends_with(b"/.") || bytes == b"."
+}
+
+/// Rust's `Path` implicitly strips trailing `/`s, however they aren't
+/// redundant in one case: at the end of a path they are the final path
+/// component, which has different path lookup behavior.
+pub(crate) fn path_has_trailing_slash(path: &Path) -> bool {
+    let bytes = path.as_os_str().as_bytes();
+
+    bytes.ends_with(b"/")
+}
+
+/// Strip trailing `/`s, unless this reduces `path` to `/` itself. This is
+/// used by `create_dir` and others to prevent paths like `foo/` from
+/// canonicalizing to `foo/.` since these syscalls treat these differently.
+#[allow(clippy::indexing_slicing)]
+pub(crate) fn strip_dir_suffix(path: &Path) -> impl Deref<Target = Path> + '_ {
+    let mut bytes = path.as_os_str().as_bytes();
+    while bytes.len() > 1 && *bytes.last().unwrap() == b'/' {
+        bytes = &bytes[..bytes.len() - 1];
+    }
+    OsStr::from_bytes(bytes).as_ref()
+}
+
+/// Return an `OpenOptions` for opening directories.
+pub(crate) fn dir_options() -> OpenOptions {
+    OpenOptions::new().read(true).dir_required(true).clone()
+}
+
+/// Like `dir_options`, but additionally request the ability to read the
+/// directory entries.
+pub(crate) fn readdir_options() -> OpenOptions {
+    OpenOptions::new()
+        .read(true)
+        .dir_required(true)
+        .readdir_required(true)
+        .clone()
+}
+
+/// Open a directory named by a bare path, using the host process' ambient
+/// authority.
+///
+/// # Ambient Authority
+///
+/// This function is not sandboxed and may trivially access any path that the
+/// host process has access to.
+pub(crate) fn open_ambient_dir_impl(path: &Path) -> io::Result<fs::File> {
+    let mut options = fs::OpenOptions::new();
+    options.read(true);
+
+    // This is for `std::fs`, so we don't have `dir_required`, so set
+    // `O_DIRECTORY` manually.
+    options.custom_flags((OFlags::DIRECTORY | target_o_path()).bits() as i32);
+
+    options.open(path)
+}
+
+/// Use `O_PATH` on platforms which have it, or none otherwise.
+#[inline]
+pub(crate) const fn target_o_path() -> OFlags {
+    #[cfg(any(
+        target_os = "android",
+        target_os = "emscripten",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "linux",
+        target_os = "redox",
+    ))]
+    {
+        OFlags::PATH
+    }
+
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "tvos",
+        target_os = "watchos",
+        target_os = "visionos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "wasi",
+        target_os = "illumos",
+        target_os = "solaris",
+    ))]
+    {
+        OFlags::empty()
+    }
+}
+
+#[test]
+fn strip_dir_suffix_tests() {
+    assert_eq!(&*strip_dir_suffix(Path::new("/foo//")), Path::new("/foo"));
+    assert_eq!(&*strip_dir_suffix(Path::new("/foo/")), Path::new("/foo"));
+    assert_eq!(&*strip_dir_suffix(Path::new("foo/")), Path::new("foo"));
+    assert_eq!(&*strip_dir_suffix(Path::new("foo")), Path::new("foo"));
+    assert_eq!(&*strip_dir_suffix(Path::new("/")), Path::new("/"));
+    assert_eq!(&*strip_dir_suffix(Path::new("//")), Path::new("/"));
+    assert_eq!(&*strip_dir_suffix(Path::new("/.")), Path::new("/."));
+    assert_eq!(&*strip_dir_suffix(Path::new("//.")), Path::new("/."));
+    assert_eq!(&*strip_dir_suffix(Path::new(".")), Path::new("."));
+    assert_eq!(&*strip_dir_suffix(Path::new("foo/.")), Path::new("foo/."));
+}
+
+#[test]
+fn test_path_requires_dir() {
+    assert!(!path_requires_dir(Path::new(".")));
+    assert!(path_requires_dir(Path::new("/")));
+    assert!(path_requires_dir(Path::new("//")));
+    assert!(path_requires_dir(Path::new("/./.")));
+    assert!(path_requires_dir(Path::new("foo/")));
+    assert!(path_requires_dir(Path::new("foo//")));
+    assert!(path_requires_dir(Path::new("foo//.")));
+    assert!(path_requires_dir(Path::new("foo/./.")));
+    assert!(path_requires_dir(Path::new("foo/./")));
+    assert!(path_requires_dir(Path::new("foo/.//")));
+}
+
+#[test]
+fn test_path_has_trailing_dot() {
+    assert!(!path_has_trailing_dot(Path::new("foo")));
+    assert!(!path_has_trailing_dot(Path::new("foo.")));
+
+    assert!(!path_has_trailing_dot(Path::new("/./foo")));
+    assert!(!path_has_trailing_dot(Path::new("..")));
+    assert!(!path_has_trailing_dot(Path::new("/..")));
+
+    assert!(!path_has_trailing_dot(Path::new("/")));
+    assert!(!path_has_trailing_dot(Path::new("//")));
+    assert!(!path_has_trailing_dot(Path::new("foo//")));
+    assert!(!path_has_trailing_dot(Path::new("foo/")));
+
+    assert!(path_has_trailing_dot(Path::new(".")));
+
+    assert!(path_has_trailing_dot(Path::new("/./.")));
+    assert!(path_has_trailing_dot(Path::new("foo//.")));
+    assert!(path_has_trailing_dot(Path::new("foo/./.")));
+    assert!(path_has_trailing_dot(Path::new("foo/./")));
+    assert!(path_has_trailing_dot(Path::new("foo/.//")));
+}
+
+#[test]
+fn test_path_has_trailing_slash() {
+    assert!(path_has_trailing_slash(Path::new("/")));
+    assert!(path_has_trailing_slash(Path::new("//")));
+    assert!(path_has_trailing_slash(Path::new("foo//")));
+    assert!(path_has_trailing_slash(Path::new("foo/")));
+    assert!(path_has_trailing_slash(Path::new("foo/./")));
+    assert!(path_has_trailing_slash(Path::new("foo/.//")));
+
+    assert!(!path_has_trailing_slash(Path::new("foo")));
+    assert!(!path_has_trailing_slash(Path::new("foo.")));
+    assert!(!path_has_trailing_slash(Path::new("/./foo")));
+    assert!(!path_has_trailing_slash(Path::new("..")));
+    assert!(!path_has_trailing_slash(Path::new("/..")));
+    assert!(!path_has_trailing_slash(Path::new(".")));
+    assert!(!path_has_trailing_slash(Path::new("/./.")));
+    assert!(!path_has_trailing_slash(Path::new("foo//.")));
+    assert!(!path_has_trailing_slash(Path::new("foo/./.")));
+}

data/ext/cargo-vendor/wasmtime-wasi-36.0.19/src/filesystem/primitives/rustix/fs/errors.rs

@@ -0,0 +1,21 @@
+use std::io;
+
+#[cold]
+pub(crate) fn no_such_file_or_directory() -> io::Error {
+    rustix::io::Errno::NOENT.into()
+}
+
+#[cold]
+pub(crate) fn is_directory() -> io::Error {
+    rustix::io::Errno::ISDIR.into()
+}
+
+#[cold]
+pub(crate) fn is_not_directory() -> io::Error {
+    rustix::io::Errno::NOTDIR.into()
+}
+
+#[cold]
+pub(crate) fn too_many_symlinks() -> io::Error {
+    rustix::io::Errno::LOOP.into()
+}

data/ext/cargo-vendor/wasmtime-wasi-36.0.19/src/filesystem/primitives/rustix/fs/file_type_ext.rs

@@ -0,0 +1,114 @@
+use crate::filesystem::primitives::FileType;
+use rustix::fs::RawMode;
+use std::{fs, io};
+
+/// A type that implements `FileTypeExt` for this platform.
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+pub(crate) enum ImplFileTypeExt {
+    Symlink,
+    BlockDevice,
+    CharDevice,
+    Fifo,
+    Socket,
+}
+
+impl ImplFileTypeExt {
+    /// Constructs a new instance of `FileType` from the given
+    /// [`std::fs::File`] and [`std::fs::FileType`].
+    #[inline]
+    #[allow(clippy::unnecessary_wraps)]
+    pub(crate) fn from(_file: &fs::File, metadata: &fs::Metadata) -> io::Result<FileType> {
+        // On `rustix`-style platforms, the `Metadata` has everything we need.
+        Ok(Self::from_just_metadata(metadata))
+    }
+
+    /// Constructs a new instance of `FileType` from the given
+    /// [`std::fs::Metadata`].
+    #[inline]
+    pub(crate) fn from_just_metadata(metadata: &fs::Metadata) -> FileType {
+        let std = metadata.file_type();
+        Self::from_std(std)
+    }
+
+    /// Constructs a new instance of `Self` from the given
+    /// [`std::fs::FileType`].
+    #[inline]
+    pub(crate) fn from_std(std: fs::FileType) -> FileType {
+        use rustix::fs::FileTypeExt;
+        if std.is_file() {
+            FileType::file()
+        } else if std.is_dir() {
+            FileType::dir()
+        } else if std.is_symlink() {
+            FileType::ext(Self::Symlink)
+        } else if std.is_block_device() {
+            FileType::ext(Self::BlockDevice)
+        } else if std.is_char_device() {
+            FileType::ext(Self::CharDevice)
+        } else {
+            #[cfg(not(target_os = "wasi"))]
+            if std.is_fifo() {
+                return FileType::ext(Self::Fifo);
+            }
+            #[cfg(not(target_os = "wasi"))]
+            if std.is_socket() {
+                return FileType::ext(Self::Socket);
+            }
+            FileType::unknown()
+        }
+    }
+
+    /// Constructs a new instance of `FileType` from the given
+    /// [`RawMode`].
+    #[inline]
+    pub(crate) const fn from_raw_mode(mode: RawMode) -> FileType {
+        match rustix::fs::FileType::from_raw_mode(mode) {
+            rustix::fs::FileType::RegularFile => FileType::file(),
+            rustix::fs::FileType::Directory => FileType::dir(),
+            rustix::fs::FileType::Symlink => FileType::ext(Self::symlink()),
+            #[cfg(not(target_os = "wasi"))]
+            rustix::fs::FileType::Fifo => FileType::ext(Self::fifo()),
+            rustix::fs::FileType::CharacterDevice => FileType::ext(Self::char_device()),
+            rustix::fs::FileType::BlockDevice => FileType::ext(Self::block_device()),
+            #[cfg(not(target_os = "wasi"))]
+            rustix::fs::FileType::Socket => FileType::ext(Self::socket()),
+            _ => FileType::unknown(),
+        }
+    }
+
+    /// Creates a `FileType` for which `is_symlink()` returns `true`.
+    #[inline]
+    pub(crate) const fn symlink() -> Self {
+        Self::Symlink
+    }
+
+    /// Creates a `FileType` for which `is_block_device()` returns `true`.
+    #[inline]
+    pub(crate) const fn block_device() -> Self {
+        Self::BlockDevice
+    }
+
+    /// Creates a `FileType` for which `is_char_device()` returns `true`.
+    #[inline]
+    pub(crate) const fn char_device() -> Self {
+        Self::CharDevice
+    }
+
+    /// Creates a `FileType` for which `is_fifo()` returns `true`.
+    #[inline]
+    pub(crate) const fn fifo() -> Self {
+        Self::Fifo
+    }
+
+    /// Creates a `FileType` for which `is_socket()` returns `true`.
+    #[inline]
+    pub(crate) const fn socket() -> Self {
+        Self::Socket
+    }
+
+    /// Tests whether this file type represents a symbolic link.
+    #[inline]
+    pub(crate) fn is_symlink(&self) -> bool {
+        *self == Self::Symlink
+    }
+}

data/ext/cargo-vendor/wasmtime-wasi-36.0.19/src/filesystem/primitives/rustix/fs/hard_link_unchecked.rs

@@ -0,0 +1,24 @@
+use rustix::fs::{AtFlags, linkat};
+use std::path::Path;
+use std::{fs, io};
+
+/// *Unsandboxed* function similar to `hard_link`, but which does not perform
+/// sandboxing.
+///
+/// Even though POSIX `linkat` has the ability to follow symlinks in
+/// `old_path`, using `AT_SYMLINK_FOLLOW`, Rust's `hard_link` doesn't need
+/// that, so we don't expose it here.
+pub(crate) fn hard_link_unchecked(
+    old_start: &fs::File,
+    old_path: &Path,
+    new_start: &fs::File,
+    new_path: &Path,
+) -> io::Result<()> {
+    Ok(linkat(
+        old_start,
+        old_path,
+        new_start,
+        new_path,
+        AtFlags::empty(),
+    )?)
+}

data/ext/cargo-vendor/wasmtime-wasi-36.0.19/src/filesystem/primitives/rustix/fs/is_same_file.rs

@@ -0,0 +1,33 @@
+use crate::filesystem::primitives::{Metadata, MetadataExt};
+use std::{fs, io};
+
+/// Determine if `a` and `b` refer to the same inode on the same device.
+pub(crate) fn is_same_file(a: &fs::File, b: &fs::File) -> io::Result<bool> {
+    let a_metadata = Metadata::from_file(a)?;
+    let b_metadata = Metadata::from_file(b)?;
+    is_same_file_metadata(&a_metadata, &b_metadata)
+}
+
+/// Determine if `a` and `b` are metadata for the same inode on the same
+/// device.
+pub(crate) fn is_same_file_metadata(a: &Metadata, b: &Metadata) -> io::Result<bool> {
+    Ok(a.dev() == b.dev() && a.ino() == b.ino())
+}
+
+/// Determine if `a` and `b` definitely refer to different inodes.
+///
+/// This is similar to `is_same_file`, but is conservative, and doesn't depend
+/// on nightly-only features.
+#[allow(dead_code)]
+pub(crate) fn is_different_file(a: &fs::File, b: &fs::File) -> io::Result<bool> {
+    is_same_file(a, b).map(|same| !same)
+}
+
+/// Determine if `a` and `b` are metadata for definitely different inodes.
+///
+/// This is similar to `is_same_file_metadata`, but is conservative, and
+/// doesn't depend on nightly-only features.
+#[allow(dead_code)]
+pub(crate) fn is_different_file_metadata(a: &Metadata, b: &Metadata) -> io::Result<bool> {
+    is_same_file_metadata(a, b).map(|same| !same)
+}

data/ext/cargo-vendor/wasmtime-wasi-36.0.19/src/filesystem/primitives/rustix/fs/metadata_ext.rs

@@ -0,0 +1,181 @@
+#![allow(clippy::useless_conversion)]
+
+use crate::filesystem::primitives::{ImplFileTypeExt, Metadata};
+use rustix::fs::{RawMode, Stat};
+#[cfg(target_os = "linux")]
+use rustix::fs::{Statx, StatxFlags, makedev};
+use std::time::{Duration, SystemTime};
+use std::{fs, io};
+
+#[derive(Debug, Clone)]
+pub(crate) struct ImplMetadataExt {
+    dev: u64,
+    ino: u64,
+    nlink: u64,
+}
+
+impl ImplMetadataExt {
+    /// Constructs a new instance of `Self` from the given [`std::fs::File`]
+    /// and [`std::fs::Metadata`].
+    #[inline]
+    #[allow(clippy::unnecessary_wraps)]
+    pub(crate) fn from(_file: &fs::File, std: &fs::Metadata) -> io::Result<Self> {
+        // On `rustix`-style platforms, the `Metadata` has everything we need.
+        Ok(Self::from_just_metadata(std))
+    }
+
+    /// Constructs a new instance of `Self` from the given
+    /// [`std::fs::Metadata`].
+    #[inline]
+    pub(crate) fn from_just_metadata(std: &fs::Metadata) -> Self {
+        use rustix::fs::MetadataExt;
+        Self {
+            dev: std.dev(),
+            ino: std.ino(),
+            nlink: std.nlink(),
+        }
+    }
+
+    /// Constructs a new instance of `Metadata` from the given `Stat`.
+    #[inline]
+    #[allow(unused_comparisons)] // NB: rust-lang/rust#115823 requires this here instead of on `st_dev` processing below
+    pub(crate) fn from_rustix(stat: Stat) -> Metadata {
+        Metadata {
+            file_type: ImplFileTypeExt::from_raw_mode(stat.st_mode as RawMode),
+            len: u64::try_from(stat.st_size).unwrap(),
+
+            #[cfg(not(target_os = "wasi"))]
+            modified: system_time_from_rustix(
+                stat.st_mtime.try_into().unwrap(),
+                stat.st_mtime_nsec as _,
+            ),
+            #[cfg(not(target_os = "wasi"))]
+            accessed: system_time_from_rustix(
+                stat.st_atime.try_into().unwrap(),
+                stat.st_atime_nsec as _,
+            ),
+
+            #[cfg(target_os = "wasi")]
+            modified: system_time_from_rustix(stat.st_mtim.tv_sec, stat.st_mtim.tv_nsec as _),
+            #[cfg(target_os = "wasi")]
+            accessed: system_time_from_rustix(stat.st_atim.tv_sec, stat.st_atim.tv_nsec as _),
+
+            #[cfg(any(
+                target_os = "freebsd",
+                target_os = "openbsd",
+                target_os = "netbsd",
+                target_os = "macos",
+                target_os = "ios",
+                target_os = "tvos",
+                target_os = "watchos",
+                target_os = "visionos",
+            ))]
+            created: system_time_from_rustix(
+                stat.st_birthtime.try_into().unwrap(),
+                stat.st_birthtime_nsec as _,
+            ),
+
+            // `stat.st_ctime` is the latest status change; we want the creation.
+            #[cfg(not(any(
+                target_os = "freebsd",
+                target_os = "openbsd",
+                target_os = "macos",
+                target_os = "ios",
+                target_os = "tvos",
+                target_os = "watchos",
+                target_os = "visionos",
+                target_os = "netbsd"
+            )))]
+            created: None,
+
+            ext: Self {
+                // The type of `st_dev` is `dev_t` which is signed on some
+                // platforms and unsigned on other platforms. A `u64` is enough
+                // to work for all unsigned platforms, and for signed platforms
+                // perform a sign extension to `i64` and then view that as an
+                // unsigned 64-bit number instead.
+                //
+                // Note that the `unused_comparisons` is ignored here for
+                // platforms where it's unsigned since the first branch here
+                // will never be taken.
+                dev: if stat.st_dev < 0 {
+                    i64::try_from(stat.st_dev).unwrap() as u64
+                } else {
+                    u64::try_from(stat.st_dev).unwrap()
+                },
+                ino: stat.st_ino.into(),
+                nlink: u64::from(stat.st_nlink),
+            },
+        }
+    }
+
+    /// Constructs a new instance of `Metadata` from the given `Statx`.
+    #[cfg(target_os = "linux")]
+    #[inline]
+    pub(crate) fn from_rustix_statx(statx: Statx) -> Metadata {
+        Metadata {
+            file_type: ImplFileTypeExt::from_raw_mode(RawMode::from(statx.stx_mode)),
+            len: u64::try_from(statx.stx_size).unwrap(),
+            modified: if statx.stx_mask & StatxFlags::MTIME.bits() != 0 {
+                system_time_from_rustix(statx.stx_mtime.tv_sec, statx.stx_mtime.tv_nsec as _)
+            } else {
+                None
+            },
+            accessed: if statx.stx_mask & StatxFlags::ATIME.bits() != 0 {
+                system_time_from_rustix(statx.stx_atime.tv_sec, statx.stx_atime.tv_nsec as _)
+            } else {
+                None
+            },
+            created: if statx.stx_mask & StatxFlags::BTIME.bits() != 0 {
+                system_time_from_rustix(statx.stx_btime.tv_sec, statx.stx_btime.tv_nsec as _)
+            } else {
+                None
+            },
+
+            ext: Self {
+                dev: makedev(statx.stx_dev_major, statx.stx_dev_minor),
+                ino: statx.stx_ino.into(),
+                nlink: u64::from(statx.stx_nlink),
+            },
+        }
+    }
+}
+
+#[allow(clippy::similar_names)]
+fn system_time_from_rustix(sec: i64, nsec: u64) -> Option<SystemTime> {
+    if sec >= 0 {
+        SystemTime::UNIX_EPOCH.checked_add(Duration::new(u64::try_from(sec).unwrap(), nsec as _))
+    } else {
+        SystemTime::UNIX_EPOCH
+            .checked_sub(Duration::new(sec.unsigned_abs(), 0))
+            .map(|t| t.checked_add(Duration::new(0, nsec as u32)))
+            .flatten()
+    }
+}
+
+impl crate::filesystem::primitives::MetadataExt for ImplMetadataExt {
+    #[inline]
+    fn dev(&self) -> u64 {
+        self.dev
+    }
+
+    #[inline]
+    fn ino(&self) -> u64 {
+        self.ino
+    }
+
+    #[inline]
+    fn nlink(&self) -> u64 {
+        self.nlink
+    }
+}
+
+/// It should be possible to represent times before the Epoch.
+/// https://github.com/bytecodealliance/cap-std/issues/328
+#[test]
+fn negative_time() {
+    let system_time = system_time_from_rustix(-1, 1).unwrap();
+    let d = SystemTime::UNIX_EPOCH.duration_since(system_time).unwrap();
+    assert_eq!(d.as_secs(), 0);
+    assert_eq!(d.subsec_nanos(), 999999999);
+}