liteboxfs 0.1.0

#[cfg(all(feature = "fs", target_os = "linux"))]
use std::path::PathBuf;

use std::os::fd::OwnedFd;

#[cfg(all(feature = "fs", target_os = "linux"))]
use nix::{
    errno::Errno,
    fcntl::{FcntlArg, fcntl},
    libc,
    unistd::Uid,
};

#[cfg(all(feature = "fs", target_os = "linux"))]
use crate::FileId;

use crate::{FilesystemId, block::FileId as StoreFileId};

#[cfg(all(feature = "fs", target_os = "linux"))]
#[cfg_attr(coverage_nightly, coverage(off))]
fn runtime_dir() -> PathBuf {
    std::env::var_os("XDG_RUNTIME_DIR")
        .map(PathBuf::from)
        .unwrap_or_else(|| PathBuf::from(format!("/run/user/{}", Uid::current())))
}

#[derive(Debug)]
pub enum LockResult {
    #[cfg_attr(not(all(feature = "fs", target_os = "linux")), allow(dead_code))]
    Acquired(LockHandle),
    Locked,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LockType {
    Read,
    Write,
}

#[derive(Debug, Clone)]
pub struct LockHandler {
    #[cfg(all(feature = "fs", target_os = "linux"))]
    lock_file_path: PathBuf,
}

#[derive(Debug)]
pub struct LockHandle {
    _fd: OwnedFd,
}

impl LockHandle {
    #[cfg_attr(not(all(feature = "fs", target_os = "linux")), allow(dead_code))]
    fn new(fd: OwnedFd) -> Self {
        Self { _fd: fd }
    }
}

impl LockHandler {
    #[cfg(all(feature = "fs", target_os = "linux"))]
    pub fn new(fs: FilesystemId) -> Self {
        Self {
            lock_file_path: runtime_dir()
                .join("liteboxfs")
                .join("fs")
                .join(fs.to_string())
                .join("handles.lock"),
        }
    }

    #[cfg(not(all(feature = "fs", target_os = "linux")))]
    pub fn new(_fs: FilesystemId) -> Self {
        Self {}
    }

    // Acquire a lock on the LiteboxFS file with the given ID, returning a handle. The lock is
    // released when the handle is dropped.
    #[cfg(all(feature = "fs", target_os = "linux"))]
    pub fn acquire_lock(&self, file: StoreFileId, kind: LockType) -> crate::Result<LockResult> {
        use std::{fs, io};

        fs::create_dir_all(
            self.lock_file_path
                .parent()
                .expect("Expected lock file path to have a parent directory."),
        )?;

        let lock_fd = fs::File::options()
            .create(true)
            .read(true)
            .append(true)
            .open(&self.lock_file_path)?
            .into();

        // We use Linux file descriptor locks, acquiring a lock on a single byte corresponding to
        // the file ID. This allows us to lock any number of LiteboxFS files within a single lock
        // file on the host filesystem.
        let result = fcntl(
            &lock_fd,
            FcntlArg::F_OFD_SETLK(&libc::flock {
                l_type: match kind {
                    LockType::Read => libc::F_RDLCK as i16,
                    LockType::Write => libc::F_WRLCK as i16,
                },
                l_whence: libc::SEEK_SET as i16,
                l_start: file.into(),
                l_len: 1,

                // This is only used when testing for the existence of a lock, not when acquiring
                // it. It returns the PID of the locking process, which is not relevant when
                // locking. This may remain "unset", which in Rust just means initialized to 0
                l_pid: 0,
            }),
        );

        match result {
            Ok(_) => Ok(LockResult::Acquired(LockHandle::new(lock_fd))),
            // The Linux API can return either of these errors to indicate a lock is already held;
            // portable implementations are required to handle both.
            Err(Errno::EAGAIN) | Err(Errno::EACCES) => Ok(LockResult::Locked),
            Err(e) => Err(crate::Error::from(io::Error::from_raw_os_error(e as i32))),
        }
    }

    #[cfg(not(all(feature = "fs", target_os = "linux")))]
    pub fn acquire_lock(&self, _file: StoreFileId, _kind: LockType) -> crate::Result<LockResult> {
        // If the `fs` feature is disabled, we should act as if all files could be open in other
        // transactions, because we have no way of knowing.
        Ok(LockResult::Locked)
    }
}

/// A raw handle to a file which can be used to prevent its deletion.
///
/// This handle can be used to keep a file which has been unlinked with [`Filesystem::unlink`] from
/// being deleted without needing to hold a [`File`], which holds an exclusive reference to the
/// filesystem.
///
/// However, unlike [`File`], **this handle does not automatically delete the file when it is
/// dropped**. For that, you must use [`Filesystem::release`]. If you fail to call
/// [`Filesystem::release`] before dropping this handle, the file will be orphaned and remain on
/// disk until either 1) another connection with an open handle deletes it or 2) it is garbage
/// collected at an unspecified later time.
///
/// You can get a [`RawFd`] by calling [`File::leak_fd`].
///
/// [`File`]: crate::File
/// [`Filesystem::unlink`]: crate::Filesystem::unlink
/// [`File::leak_fd`]: crate::File::leak_fd
/// [`Filesystem::release`]: crate::Filesystem::release
#[cfg(all(feature = "fs", target_os = "linux"))]
pub struct RawFd {
    _handle: LockHandle,
    file_id: StoreFileId,
    filesystem_id: FilesystemId,
}

#[cfg(all(feature = "fs", target_os = "linux"))]
impl RawFd {
    pub(crate) fn new(
        handle: LockHandle,
        file_id: StoreFileId,
        filesystem_id: FilesystemId,
    ) -> Self {
        Self {
            _handle: handle,
            file_id,
            filesystem_id,
        }
    }

    pub(crate) fn into_file_id(self) -> StoreFileId {
        self.file_id
    }

    /// The [`FileId`] of the file associated with this raw file descriptor.
    pub fn file_id(&self) -> FileId {
        FileId::new(self.file_id, self.filesystem_id)
    }
}

#[cfg(all(feature = "fs", target_os = "linux"))]
#[cfg_attr(coverage_nightly, coverage(off))]
impl std::fmt::Debug for RawFd {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_tuple("RawFd").field(&self.file_id).finish()
    }
}