ci: patch vendor/fs2

Author: itsezc

Cargo.lock

@@ -4,3 +4,6 @@ members = [
 	'crates/embedded-ffi'
 ]
 default-members = ['crates/embedded-ffi']
+
+[patch.crates-io]
+fs2 = { path = 'vendor/fs2' }

Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "fs2"
+version = "0.4.3"
+edition = "2015"
+authors = ["Dan Burkert <dan@danburkert.com>"]
+description = "Cross-platform file locks and file duplication."
+documentation = "https://docs.rs/fs2"
+keywords = ["file", "file-system", "lock", "duplicate", "flock"]
+license = "MIT/Apache-2.0"
+repository = "https://github.com/danburkert/fs2-rs"
+
+[target.'cfg(unix)'.dependencies]
+libc = "0.2.30"
+
+[target.'cfg(windows)'.dependencies]
+winapi = { version = "0.3", features = ["handleapi", "processthreadsapi", "winerror", "fileapi", "winbase", "std"] }

vendor/fs2/Cargo.toml

@@ -0,0 +1,125 @@
+//! Extended utilities for working with files and filesystems in Rust.
+
+#![doc(html_root_url = "https://docs.rs/fs2/0.4.3")]
+#![cfg_attr(test, feature(test))]
+
+#[cfg(windows)]
+extern crate winapi;
+
+#[cfg(unix)]
+mod unix;
+#[cfg(unix)]
+use unix as sys;
+
+#[cfg(windows)]
+mod windows;
+#[cfg(windows)]
+use windows as sys;
+
+use std::fs::File;
+use std::io::{Error, Result};
+use std::path::Path;
+
+/// Extension trait for `std::fs::File` which provides allocation, duplication and locking methods.
+pub trait FileExt {
+    fn duplicate(&self) -> Result<File>;
+    fn allocated_size(&self) -> Result<u64>;
+    fn allocate(&self, len: u64) -> Result<()>;
+    fn lock_shared(&self) -> Result<()>;
+    fn lock_exclusive(&self) -> Result<()>;
+    fn try_lock_shared(&self) -> Result<()>;
+    fn try_lock_exclusive(&self) -> Result<()>;
+    fn unlock(&self) -> Result<()>;
+}
+
+impl FileExt for File {
+    fn duplicate(&self) -> Result<File> {
+        sys::duplicate(self)
+    }
+    fn allocated_size(&self) -> Result<u64> {
+        sys::allocated_size(self)
+    }
+    fn allocate(&self, len: u64) -> Result<()> {
+        sys::allocate(self, len)
+    }
+    fn lock_shared(&self) -> Result<()> {
+        sys::lock_shared(self)
+    }
+    fn lock_exclusive(&self) -> Result<()> {
+        sys::lock_exclusive(self)
+    }
+    fn try_lock_shared(&self) -> Result<()> {
+        sys::try_lock_shared(self)
+    }
+    fn try_lock_exclusive(&self) -> Result<()> {
+        sys::try_lock_exclusive(self)
+    }
+    fn unlock(&self) -> Result<()> {
+        sys::unlock(self)
+    }
+}
+
+pub fn lock_contended_error() -> Error {
+    sys::lock_error()
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct FsStats {
+    free_space: u64,
+    available_space: u64,
+    total_space: u64,
+    allocation_granularity: u64,
+}
+
+impl FsStats {
+    pub fn free_space(&self) -> u64 {
+        self.free_space
+    }
+
+    pub fn available_space(&self) -> u64 {
+        self.available_space
+    }
+
+    pub fn total_space(&self) -> u64 {
+        self.total_space
+    }
+
+    pub fn allocation_granularity(&self) -> u64 {
+        self.allocation_granularity
+    }
+}
+
+pub fn statvfs<P>(path: P) -> Result<FsStats>
+where
+    P: AsRef<Path>,
+{
+    sys::statvfs(path.as_ref())
+}
+
+pub fn free_space<P>(path: P) -> Result<u64>
+where
+    P: AsRef<Path>,
+{
+    statvfs(path).map(|stat| stat.free_space)
+}
+
+pub fn available_space<P>(path: P) -> Result<u64>
+where
+    P: AsRef<Path>,
+{
+    statvfs(path).map(|stat| stat.available_space)
+}
+
+pub fn total_space<P>(path: P) -> Result<u64>
+where
+    P: AsRef<Path>,
+{
+    statvfs(path).map(|stat| stat.total_space)
+}
+
+pub fn allocation_granularity<P>(path: P) -> Result<u64>
+where
+    P: AsRef<Path>,
+{
+    statvfs(path).map(|stat| stat.allocation_granularity)
+}

vendor/fs2/src/lib.rs

@@ -0,0 +1,182 @@
+extern crate libc;
+
+use std::ffi::CString;
+use std::fs::File;
+use std::io::{Error, ErrorKind, Result};
+use std::mem;
+use std::os::unix::ffi::OsStrExt;
+use std::os::unix::fs::MetadataExt;
+use std::os::unix::io::{AsRawFd, FromRawFd};
+use std::path::Path;
+
+use FsStats;
+
+pub fn duplicate(file: &File) -> Result<File> {
+    unsafe {
+        let fd = libc::dup(file.as_raw_fd());
+
+        if fd < 0 {
+            Err(Error::last_os_error())
+        } else {
+            Ok(File::from_raw_fd(fd))
+        }
+    }
+}
+
+pub fn lock_shared(file: &File) -> Result<()> {
+    flock(file, libc::LOCK_SH)
+}
+
+pub fn lock_exclusive(file: &File) -> Result<()> {
+    flock(file, libc::LOCK_EX)
+}
+
+pub fn try_lock_shared(file: &File) -> Result<()> {
+    flock(file, libc::LOCK_SH | libc::LOCK_NB)
+}
+
+pub fn try_lock_exclusive(file: &File) -> Result<()> {
+    flock(file, libc::LOCK_EX | libc::LOCK_NB)
+}
+
+pub fn unlock(file: &File) -> Result<()> {
+    flock(file, libc::LOCK_UN)
+}
+
+pub fn lock_error() -> Error {
+    Error::from_raw_os_error(libc::EWOULDBLOCK)
+}
+
+#[cfg(not(target_os = "solaris"))]
+fn flock(file: &File, flag: libc::c_int) -> Result<()> {
+    let ret = unsafe { libc::flock(file.as_raw_fd(), flag) };
+    if ret < 0 {
+        Err(Error::last_os_error())
+    } else {
+        Ok(())
+    }
+}
+
+#[cfg(target_os = "solaris")]
+fn flock(file: &File, flag: libc::c_int) -> Result<()> {
+    let mut fl = libc::flock {
+        l_whence: 0,
+        l_start: 0,
+        l_len: 0,
+        l_type: 0,
+        l_pad: [0; 4],
+        l_pid: 0,
+        l_sysid: 0,
+    };
+
+    let (cmd, operation) = match flag & libc::LOCK_NB {
+        0 => (libc::F_SETLKW, flag),
+        _ => (libc::F_SETLK, flag & !libc::LOCK_NB),
+    };
+
+    match operation {
+        libc::LOCK_SH => fl.l_type |= libc::F_RDLCK,
+        libc::LOCK_EX => fl.l_type |= libc::F_WRLCK,
+        libc::LOCK_UN => fl.l_type |= libc::F_UNLCK,
+        _ => return Err(Error::from_raw_os_error(libc::EINVAL)),
+    }
+
+    let ret = unsafe { libc::fcntl(file.as_raw_fd(), cmd, &fl) };
+    match ret {
+        -1 => match Error::last_os_error().raw_os_error() {
+            Some(libc::EACCES) => Err(lock_error()),
+            _ => Err(Error::last_os_error()),
+        },
+        _ => Ok(()),
+    }
+}
+
+pub fn allocated_size(file: &File) -> Result<u64> {
+    file.metadata().map(|m| m.blocks() as u64 * 512)
+}
+
+#[cfg(any(
+    target_os = "linux",
+    target_os = "freebsd",
+    target_os = "android"
+))]
+pub fn allocate(file: &File, len: u64) -> Result<()> {
+    let ret = unsafe { libc::posix_fallocate(file.as_raw_fd(), 0, len as libc::off_t) };
+    if ret == 0 {
+        Ok(())
+    } else {
+        Err(Error::last_os_error())
+    }
+}
+
+#[cfg(any(
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "tvos",
+    target_os = "watchos",
+    target_os = "visionos"
+))]
+pub fn allocate(file: &File, len: u64) -> Result<()> {
+    let stat = file.metadata()?;
+
+    if len > stat.blocks() as u64 * 512 {
+        let mut fstore = libc::fstore_t {
+            fst_flags: libc::F_ALLOCATECONTIG,
+            fst_posmode: libc::F_PEOFPOSMODE,
+            fst_offset: 0,
+            fst_length: len as libc::off_t,
+            fst_bytesalloc: 0,
+        };
+
+        let ret = unsafe { libc::fcntl(file.as_raw_fd(), libc::F_PREALLOCATE, &fstore) };
+        if ret == -1 {
+            fstore.fst_flags = libc::F_ALLOCATEALL;
+            let ret = unsafe { libc::fcntl(file.as_raw_fd(), libc::F_PREALLOCATE, &fstore) };
+            if ret == -1 {
+                return Err(Error::last_os_error());
+            }
+        }
+    }
+
+    if len > stat.size() as u64 {
+        file.set_len(len)
+    } else {
+        Ok(())
+    }
+}
+
+#[cfg(any(
+    target_os = "openbsd",
+    target_os = "netbsd",
+    target_os = "dragonfly",
+    target_os = "solaris",
+    target_os = "haiku"
+))]
+pub fn allocate(file: &File, len: u64) -> Result<()> {
+    if len > file.metadata()?.len() as u64 {
+        file.set_len(len)
+    } else {
+        Ok(())
+    }
+}
+
+pub fn statvfs(path: &Path) -> Result<FsStats> {
+    let cstr = match CString::new(path.as_os_str().as_bytes()) {
+        Ok(cstr) => cstr,
+        Err(..) => return Err(Error::new(ErrorKind::InvalidInput, "path contained a null")),
+    };
+
+    unsafe {
+        let mut stat: libc::statvfs = mem::zeroed();
+        if libc::statvfs(cstr.as_ptr() as *const _, &mut stat) != 0 {
+            Err(Error::last_os_error())
+        } else {
+            Ok(FsStats {
+                free_space: stat.f_frsize as u64 * stat.f_bfree as u64,
+                available_space: stat.f_frsize as u64 * stat.f_bavail as u64,
+                total_space: stat.f_frsize as u64 * stat.f_blocks as u64,
+                allocation_granularity: stat.f_frsize as u64,
+            })
+        }
+    }
+}