Merge pull request #170 from Berrysoft/dev/statx

feat(fs,driver): add async metadata

Author: Berrysoft

compio-driver/src/fusion/op.rs

@@ -1,3 +1,5 @@
+use std::ffi::CString;
+
 use compio_buf::{IntoInner, IoBuf, IoBufMut, IoVectoredBuf, IoVectoredBufMut};
 use socket2::SockAddr;
 
@@ -93,3 +95,5 @@ op!(<T: IoBufMut> RecvFrom(fd: RawFd, buffer: T));
 op!(<T: IoBuf> SendTo(fd: RawFd, buffer: T, addr: SockAddr));
 op!(<T: IoVectoredBufMut> RecvFromVectored(fd: RawFd, buffer: T));
 op!(<T: IoVectoredBuf> SendToVectored(fd: RawFd, buffer: T, addr: SockAddr));
+op!(<> FileStat(fd: RawFd));
+op!(<> PathStat(path: CString, follow_symlink: bool));

compio-driver/src/iocp/op.rs

@@ -3,6 +3,7 @@ use std::sync::OnceLock;
 use std::{
     io,
     net::Shutdown,
+    os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle},
     pin::Pin,
     ptr::{null, null_mut},
     task::Poll,
@@ -18,8 +19,9 @@ use windows_sys::{
     core::GUID,
     Win32::{
         Foundation::{
-            CloseHandle, GetLastError, ERROR_HANDLE_EOF, ERROR_IO_INCOMPLETE, ERROR_IO_PENDING,
-            ERROR_NOT_FOUND, ERROR_NO_DATA, ERROR_PIPE_CONNECTED,
+            CloseHandle, GetLastError, ERROR_ACCESS_DENIED, ERROR_HANDLE_EOF, ERROR_IO_INCOMPLETE,
+            ERROR_IO_PENDING, ERROR_NOT_FOUND, ERROR_NO_DATA, ERROR_PIPE_CONNECTED,
+            ERROR_SHARING_VIOLATION, FILETIME,
         },
         Networking::WinSock::{
             closesocket, setsockopt, shutdown, socklen_t, WSAIoctl, WSARecv, WSARecvFrom, WSASend,
@@ -30,8 +32,12 @@ use windows_sys::{
         },
         Security::SECURITY_ATTRIBUTES,
         Storage::FileSystem::{
-            CreateFileW, FlushFileBuffers, ReadFile, WriteFile, FILE_CREATION_DISPOSITION,
-            FILE_FLAGS_AND_ATTRIBUTES, FILE_SHARE_MODE,
+            CreateFileW, FileAttributeTagInfo, FindClose, FindFirstFileW, FlushFileBuffers,
+            GetFileInformationByHandle, GetFileInformationByHandleEx, ReadFile, WriteFile,
+            BY_HANDLE_FILE_INFORMATION, FILE_ATTRIBUTE_REPARSE_POINT, FILE_ATTRIBUTE_TAG_INFO,
+            FILE_CREATION_DISPOSITION, FILE_FLAGS_AND_ATTRIBUTES, FILE_FLAG_BACKUP_SEMANTICS,
+            FILE_FLAG_OPEN_REPARSE_POINT, FILE_SHARE_DELETE, FILE_SHARE_MODE, FILE_SHARE_READ,
+            FILE_SHARE_WRITE, OPEN_EXISTING, WIN32_FIND_DATAW,
         },
         System::{
             Pipes::ConnectNamedPipe,
@@ -201,6 +207,222 @@ impl OpCode for CloseFile {
     }
 }
 
+/// A mixture of [`BY_HANDLE_FILE_INFORMATION`], [`FILE_ATTRIBUTE_TAG_INFO`] and
+/// [`WIN32_FIND_DATAW`]. The field names follows Hungarian case, to make it
+/// look like Windows API.
+#[derive(Default, Clone)]
+#[allow(non_snake_case, missing_docs)]
+pub struct FileMetadata {
+    pub dwFileAttributes: u32,
+    pub ftCreationTime: u64,
+    pub ftLastAccessTime: u64,
+    pub ftLastWriteTime: u64,
+    pub nFileSize: u64,
+    pub dwReparseTag: u32,
+    pub dwVolumeSerialNumber: Option<u32>,
+    pub nNumberOfLinks: Option<u32>,
+    pub nFileIndex: Option<u64>,
+}
+
+impl FileMetadata {
+    fn is_reparse_point(&self) -> bool {
+        self.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT != 0
+    }
+}
+
+const fn create_u64(high: u32, low: u32) -> u64 {
+    ((high as u64) << 32) | (low as u64)
+}
+
+const fn filetime_u64(t: FILETIME) -> u64 {
+    create_u64(t.dwHighDateTime, t.dwLowDateTime)
+}
+
+impl From<BY_HANDLE_FILE_INFORMATION> for FileMetadata {
+    fn from(value: BY_HANDLE_FILE_INFORMATION) -> Self {
+        Self {
+            dwFileAttributes: value.dwFileAttributes,
+            ftCreationTime: filetime_u64(value.ftCreationTime),
+            ftLastAccessTime: filetime_u64(value.ftLastAccessTime),
+            ftLastWriteTime: filetime_u64(value.ftLastWriteTime),
+            nFileSize: create_u64(value.nFileSizeHigh, value.nFileSizeLow),
+            dwReparseTag: 0,
+            dwVolumeSerialNumber: Some(value.dwVolumeSerialNumber),
+            nNumberOfLinks: Some(value.nNumberOfLinks),
+            nFileIndex: Some(create_u64(value.nFileIndexHigh, value.nFileIndexLow)),
+        }
+    }
+}
+
+impl From<WIN32_FIND_DATAW> for FileMetadata {
+    fn from(value: WIN32_FIND_DATAW) -> Self {
+        let mut this = Self {
+            dwFileAttributes: value.dwFileAttributes,
+            ftCreationTime: filetime_u64(value.ftCreationTime),
+            ftLastAccessTime: filetime_u64(value.ftLastAccessTime),
+            ftLastWriteTime: filetime_u64(value.ftLastWriteTime),
+            nFileSize: create_u64(value.nFileSizeHigh, value.nFileSizeLow),
+            dwReparseTag: 0,
+            dwVolumeSerialNumber: None,
+            nNumberOfLinks: None,
+            nFileIndex: None,
+        };
+        if this.is_reparse_point() {
+            this.dwReparseTag = value.dwReserved0;
+        }
+        this
+    }
+}
+
+/// Get metadata of an opened file.
+pub struct FileStat {
+    pub(crate) fd: RawFd,
+    pub(crate) stat: FileMetadata,
+}
+
+impl FileStat {
+    /// Create [`FileStat`].
+    pub fn new(fd: RawFd) -> Self {
+        Self {
+            fd,
+            stat: Default::default(),
+        }
+    }
+}
+
+impl OpCode for FileStat {
+    fn is_overlapped(&self) -> bool {
+        false
+    }
+
+    unsafe fn operate(mut self: Pin<&mut Self>, _optr: *mut OVERLAPPED) -> Poll<io::Result<usize>> {
+        let mut stat = unsafe { std::mem::zeroed() };
+        syscall!(BOOL, GetFileInformationByHandle(self.fd as _, &mut stat))?;
+        self.stat = stat.into();
+        if self.stat.is_reparse_point() {
+            let mut tag: FILE_ATTRIBUTE_TAG_INFO = std::mem::zeroed();
+            syscall!(
+                BOOL,
+                GetFileInformationByHandleEx(
+                    self.fd as _,
+                    FileAttributeTagInfo,
+                    &mut tag as *mut _ as _,
+                    std::mem::size_of::<FILE_ATTRIBUTE_TAG_INFO>() as _
+                )
+            )?;
+            debug_assert_eq!(self.stat.dwFileAttributes, tag.FileAttributes);
+            self.stat.dwReparseTag = tag.ReparseTag;
+        }
+        Poll::Ready(Ok(0))
+    }
+
+    unsafe fn cancel(self: Pin<&mut Self>, _optr: *mut OVERLAPPED) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl IntoInner for FileStat {
+    type Inner = FileMetadata;
+
+    fn into_inner(self) -> Self::Inner {
+        self.stat
+    }
+}
+
+/// Get metadata from path.
+pub struct PathStat {
+    pub(crate) path: U16CString,
+    pub(crate) follow_symlink: bool,
+    pub(crate) stat: FileMetadata,
+}
+
+impl PathStat {
+    /// Create [`PathStat`].
+    pub fn new(path: U16CString, follow_symlink: bool) -> Self {
+        Self {
+            path,
+            follow_symlink,
+            stat: Default::default(),
+        }
+    }
+
+    unsafe fn open_and_stat(&self, optr: *mut OVERLAPPED) -> io::Result<FileMetadata> {
+        let mut flags = FILE_FLAG_BACKUP_SEMANTICS;
+        if !self.follow_symlink {
+            flags |= FILE_FLAG_OPEN_REPARSE_POINT;
+        }
+        let handle = syscall!(
+            HANDLE,
+            CreateFileW(
+                self.path.as_ptr(),
+                0,
+                FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                null(),
+                OPEN_EXISTING,
+                flags,
+                0
+            )
+        )?;
+        let handle = OwnedHandle::from_raw_handle(handle as _);
+        let mut op = FileStat::new(handle.as_raw_handle());
+        let op_pin = std::pin::Pin::new(&mut op);
+        let res = op_pin.operate(optr);
+        if let Poll::Ready(res) = res {
+            res.map(|_| op.into_inner())
+        } else {
+            unreachable!("FileStat could not return Poll::Pending")
+        }
+    }
+}
+
+impl OpCode for PathStat {
+    fn is_overlapped(&self) -> bool {
+        false
+    }
+
+    unsafe fn operate(mut self: Pin<&mut Self>, optr: *mut OVERLAPPED) -> Poll<io::Result<usize>> {
+        let res = match self.open_and_stat(optr) {
+            Ok(stat) => {
+                self.stat = stat;
+                Ok(0)
+            }
+            Err(e)
+                if [
+                    Some(ERROR_SHARING_VIOLATION as _),
+                    Some(ERROR_ACCESS_DENIED as _),
+                ]
+                .contains(&e.raw_os_error()) =>
+            {
+                let mut wfd: WIN32_FIND_DATAW = std::mem::zeroed();
+                let handle = syscall!(HANDLE, FindFirstFileW(self.path.as_ptr(), &mut wfd))?;
+                FindClose(handle);
+                self.stat = wfd.into();
+                let is_reparse = self.stat.is_reparse_point();
+                let surrogate = self.stat.dwReparseTag & 0x20000000 != 0;
+                if self.follow_symlink && is_reparse && surrogate {
+                    Err(e)
+                } else {
+                    Ok(0)
+                }
+            }
+            Err(e) => Err(e),
+        };
+        Poll::Ready(res)
+    }
+
+    unsafe fn cancel(self: Pin<&mut Self>, _optr: *mut OVERLAPPED) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl IntoInner for PathStat {
+    type Inner = FileMetadata;
+
+    fn into_inner(self) -> Self::Inner {
+        self.stat
+    }
+}
+
 impl<T: IoBufMut> OpCode for ReadAt<T> {
     unsafe fn operate(mut self: Pin<&mut Self>, optr: *mut OVERLAPPED) -> Poll<io::Result<usize>> {
         if let Some(overlapped) = optr.as_mut() {

compio-driver/src/iour/op.rs

@@ -1,4 +1,4 @@
-use std::{os::fd::RawFd, pin::Pin};
+use std::{ffi::CString, os::fd::RawFd, pin::Pin};
 
 use compio_buf::{
     BufResult, IntoInner, IoBuf, IoBufMut, IoSlice, IoSliceMut, IoVectoredBuf, IoVectoredBufMut,
@@ -50,6 +50,87 @@ impl OpCode for CloseFile {
     }
 }
 
+/// Get metadata of an opened file.
+pub struct FileStat {
+    pub(crate) fd: RawFd,
+    pub(crate) stat: libc::statx,
+}
+
+impl FileStat {
+    /// Create [`FileStat`].
+    pub fn new(fd: RawFd) -> Self {
+        Self {
+            fd,
+            stat: unsafe { std::mem::zeroed() },
+        }
+    }
+}
+
+impl OpCode for FileStat {
+    fn create_entry(mut self: Pin<&mut Self>) -> OpEntry {
+        static EMPTY_NAME: &[u8] = b"\0";
+        opcode::Statx::new(
+            Fd(self.fd),
+            EMPTY_NAME.as_ptr().cast(),
+            std::ptr::addr_of_mut!(self.stat).cast(),
+        )
+        .flags(libc::AT_EMPTY_PATH)
+        .build()
+        .into()
+    }
+}
+
+impl IntoInner for FileStat {
+    type Inner = libc::stat;
+
+    fn into_inner(self) -> Self::Inner {
+        statx_to_stat(self.stat)
+    }
+}
+
+/// Get metadata from path.
+pub struct PathStat {
+    pub(crate) path: CString,
+    pub(crate) stat: libc::statx,
+    pub(crate) follow_symlink: bool,
+}
+
+impl PathStat {
+    /// Create [`PathStat`].
+    pub fn new(path: CString, follow_symlink: bool) -> Self {
+        Self {
+            path,
+            stat: unsafe { std::mem::zeroed() },
+            follow_symlink,
+        }
+    }
+}
+
+impl OpCode for PathStat {
+    fn create_entry(mut self: Pin<&mut Self>) -> OpEntry {
+        let mut flags = libc::AT_EMPTY_PATH;
+        if !self.follow_symlink {
+            flags |= libc::AT_SYMLINK_NOFOLLOW;
+        }
+        opcode::Statx::new(
+            Fd(libc::AT_FDCWD),
+            self.path.as_ptr(),
+            std::ptr::addr_of_mut!(self.stat).cast(),
+        )
+        .flags(flags)
+        .build()
+        .into()
+    }
+}
+
+impl IntoInner for PathStat {
+    type Inner = libc::stat;
+
+    fn into_inner(self) -> Self::Inner {
+        statx_to_stat(self.stat)
+    }
+}
+
 impl<T: IoBufMut> OpCode for ReadAt<T> {
     fn create_entry(mut self: Pin<&mut Self>) -> OpEntry {
         let fd = Fd(self.fd);

compio-driver/src/op.rs

@@ -8,12 +8,12 @@ use std::net::Shutdown;
 use compio_buf::{BufResult, IntoInner, IoBuf, IoBufMut, SetBufInit};
 use socket2::SockAddr;
 
-#[cfg(windows)]
-pub use crate::sys::op::ConnectNamedPipe;
 pub use crate::sys::op::{
-    Accept, OpenFile, Recv, RecvFrom, RecvFromVectored, RecvVectored, Send, SendTo, SendToVectored,
-    SendVectored,
+    Accept, FileStat, OpenFile, PathStat, Recv, RecvFrom, RecvFromVectored, RecvVectored, Send,
+    SendTo, SendToVectored, SendVectored,
 };
+#[cfg(windows)]
+pub use crate::sys::op::{ConnectNamedPipe, FileMetadata};
 #[cfg(unix)]
 pub use crate::sys::op::{ReadVectoredAt, WriteVectoredAt};
 use crate::sys::{sockaddr_storage, socklen_t, RawFd};