Merge branch 'main' of github.com:rustfs/s3-rustfs into feature/observability-metrics

# Conflicts: # .github/workflows/build.yml # .github/workflows/ci.yml # Cargo.lock # Cargo.toml # appauth/src/token.rs # crates/config/src/config.rs # crates/event-notifier/examples/simple.rs # crates/event-notifier/src/global.rs # crates/event-notifier/src/lib.rs # crates/event-notifier/src/notifier.rs # crates/event-notifier/src/store.rs # crates/filemeta/src/filemeta.rs # crates/notify/examples/webhook.rs # crates/utils/Cargo.toml # ecstore/Cargo.toml # ecstore/src/cmd/bucket_replication.rs # ecstore/src/config/com.rs # ecstore/src/disk/error.rs # ecstore/src/disk/mod.rs # ecstore/src/set_disk.rs # ecstore/src/store_api.rs # ecstore/src/store_list_objects.rs # iam/Cargo.toml # iam/src/manager.rs # policy/Cargo.toml # rustfs/src/admin/rpc.rs # rustfs/src/main.rs # rustfs/src/storage/mod.rs
2026-08-08 14:23:13 +00:00 · 2025-06-19 13:16:48 +08:00
parent 09e8bc8f02 450db14305
commit e6b019c29d
249 changed files with 25137 additions and 11731 deletions
@@ -0,0 +1,176 @@
+use nix::sys::stat::{self, stat};
+use nix::sys::statfs::{self, FsType, statfs};
+use std::fs::File;
+use std::io::{self, BufRead, Error, ErrorKind};
+use std::path::Path;
+
+use super::{DiskInfo, IOStats};
+
+/// Returns total and free bytes available in a directory, e.g. `/`.
+pub fn get_info(p: impl AsRef<Path>) -> std::io::Result<DiskInfo> {
+    let stat_fs = statfs(p.as_ref())?;
+
+    let bsize = stat_fs.block_size() as u64;
+    let bfree = stat_fs.blocks_free() as u64;
+    let bavail = stat_fs.blocks_available() as u64;
+    let blocks = stat_fs.blocks() as u64;
+
+    let reserved = match bfree.checked_sub(bavail) {
+        Some(reserved) => reserved,
+        None => {
+            return Err(Error::other(format!(
+                "detected f_bavail space ({}) > f_bfree space ({}), fs corruption at ({}). please run 'fsck'",
+                bavail,
+                bfree,
+                p.as_ref().display()
+            )));
+        }
+    };
+
+    let total = match blocks.checked_sub(reserved) {
+        Some(total) => total * bsize,
+        None => {
+            return Err(Error::other(format!(
+                "detected reserved space ({}) > blocks space ({}), fs corruption at ({}). please run 'fsck'",
+                reserved,
+                blocks,
+                p.as_ref().display()
+            )));
+        }
+    };
+
+    let free = bavail * bsize;
+    let used = match total.checked_sub(free) {
+        Some(used) => used,
+        None => {
+            return Err(Error::other(format!(
+                "detected free space ({}) > total drive space ({}), fs corruption at ({}). please run 'fsck'",
+                free,
+                total,
+                p.as_ref().display()
+            )));
+        }
+    };
+
+    let st = stat(p.as_ref())?;
+
+    Ok(DiskInfo {
+        total,
+        free,
+        used,
+        files: stat_fs.files(),
+        ffree: stat_fs.files_free(),
+        fstype: get_fs_type(stat_fs.filesystem_type()).to_string(),
+        major: stat::major(st.st_dev),
+        minor: stat::minor(st.st_dev),
+        ..Default::default()
+    })
+}
+
+/// Returns the filesystem type of the underlying mounted filesystem
+///
+/// TODO The following mapping could not find the corresponding constant in `nix`:
+///
+/// "137d" => "EXT",
+/// "4244" => "HFS",
+/// "5346544e" => "NTFS",
+/// "61756673" => "AUFS",
+/// "ef51" => "EXT2OLD",
+/// "2fc12fc1" => "zfs",
+/// "ff534d42" => "cifs",
+/// "53464846" => "wslfs",
+fn get_fs_type(fs_type: FsType) -> &'static str {
+    match fs_type {
+        statfs::TMPFS_MAGIC => "TMPFS",
+        statfs::MSDOS_SUPER_MAGIC => "MSDOS",
+        // statfs::XFS_SUPER_MAGIC => "XFS",
+        statfs::NFS_SUPER_MAGIC => "NFS",
+        statfs::EXT4_SUPER_MAGIC => "EXT4",
+        statfs::ECRYPTFS_SUPER_MAGIC => "ecryptfs",
+        statfs::OVERLAYFS_SUPER_MAGIC => "overlayfs",
+        statfs::REISERFS_SUPER_MAGIC => "REISERFS",
+        _ => "UNKNOWN",
+    }
+}
+
+pub fn same_disk(disk1: &str, disk2: &str) -> std::io::Result<bool> {
+    let stat1 = stat(disk1)?;
+    let stat2 = stat(disk2)?;
+
+    Ok(stat1.st_dev == stat2.st_dev)
+}
+
+pub fn get_drive_stats(major: u32, minor: u32) -> std::io::Result<IOStats> {
+    read_drive_stats(&format!("/sys/dev/block/{}:{}/stat", major, minor))
+}
+
+fn read_drive_stats(stats_file: &str) -> std::io::Result<IOStats> {
+    let stats = read_stat(stats_file)?;
+    if stats.len() < 11 {
+        return Err(Error::new(
+            ErrorKind::InvalidData,
+            format!("found invalid format while reading {}", stats_file),
+        ));
+    }
+    let mut io_stats = IOStats {
+        read_ios: stats[0],
+        read_merges: stats[1],
+        read_sectors: stats[2],
+        read_ticks: stats[3],
+        write_ios: stats[4],
+        write_merges: stats[5],
+        write_sectors: stats[6],
+        write_ticks: stats[7],
+        current_ios: stats[8],
+        total_ticks: stats[9],
+        req_ticks: stats[10],
+        ..Default::default()
+    };
+
+    if stats.len() > 14 {
+        io_stats.discard_ios = stats[11];
+        io_stats.discard_merges = stats[12];
+        io_stats.discard_sectors = stats[13];
+        io_stats.discard_ticks = stats[14];
+    }
+    Ok(io_stats)
+}
+
+fn read_stat(file_name: &str) -> std::io::Result<Vec<u64>> {
+    // Open file
+    let path = Path::new(file_name);
+    let file = File::open(path)?;
+
+    // Create a BufReader
+    let reader = io::BufReader::new(file);
+
+    // Read first line
+    let mut stats = Vec::new();
+    if let Some(line) = reader.lines().next() {
+        let line = line?;
+        // Split line and parse as u64
+        // https://rust-lang.github.io/rust-clippy/master/index.html#trim_split_whitespace
+        for token in line.split_whitespace() {
+            let ui64: u64 = token
+                .parse()
+                .map_err(|e| Error::new(ErrorKind::InvalidData, format!("failed to parse '{}' as u64: {}", token, e)))?;
+            stats.push(ui64);
+        }
+    }
+
+    Ok(stats)
+}
+
+#[cfg(test)]
+mod test {
+    use super::get_drive_stats;
+
+    #[ignore] // FIXME: failed in github actions
+    #[test]
+    fn test_stats() {
+        let major = 7;
+        let minor = 11;
+        let s = get_drive_stats(major, minor).unwrap();
+        println!("{:?}", s);
+    }
+}
@@ -0,0 +1,111 @@
+#[cfg(target_os = "linux")]
+mod linux;
+#[cfg(all(unix, not(target_os = "linux")))]
+mod unix;
+#[cfg(target_os = "windows")]
+mod windows;
+
+#[cfg(target_os = "linux")]
+pub use linux::{get_drive_stats, get_info, same_disk};
+// pub use linux::same_disk;
+
+#[cfg(all(unix, not(target_os = "linux")))]
+pub use unix::{get_drive_stats, get_info, same_disk};
+#[cfg(target_os = "windows")]
+pub use windows::{get_drive_stats, get_info, same_disk};
+
+#[derive(Debug, Default, PartialEq)]
+pub struct IOStats {
+    pub read_ios: u64,
+    pub read_merges: u64,
+    pub read_sectors: u64,
+    pub read_ticks: u64,
+    pub write_ios: u64,
+    pub write_merges: u64,
+    pub write_sectors: u64,
+    pub write_ticks: u64,
+    pub current_ios: u64,
+    pub total_ticks: u64,
+    pub req_ticks: u64,
+    pub discard_ios: u64,
+    pub discard_merges: u64,
+    pub discard_sectors: u64,
+    pub discard_ticks: u64,
+    pub flush_ios: u64,
+    pub flush_ticks: u64,
+}
+
+#[derive(Debug, Default, PartialEq)]
+pub struct DiskInfo {
+    pub total: u64,
+    pub free: u64,
+    pub used: u64,
+    pub files: u64,
+    pub ffree: u64,
+    pub fstype: String,
+    pub major: u64,
+    pub minor: u64,
+    pub name: String,
+    pub rotational: bool,
+    pub nrrequests: u64,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    #[test]
+    fn test_get_info_valid_path() {
+        let temp_dir = tempfile::tempdir().unwrap();
+        let info = get_info(temp_dir.path()).unwrap();
+
+        println!("Disk Info: {:?}", info);
+
+        assert!(info.total > 0);
+        assert!(info.free > 0);
+        assert!(info.used > 0);
+        assert!(info.files > 0);
+        assert!(info.ffree > 0);
+        assert!(!info.fstype.is_empty());
+    }
+
+    #[test]
+    fn test_get_info_invalid_path() {
+        let invalid_path = PathBuf::from("/invalid/path");
+        let result = get_info(&invalid_path);
+
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_same_disk_same_path() {
+        let temp_dir = tempfile::tempdir().unwrap();
+        let path = temp_dir.path().to_str().unwrap();
+
+        let result = same_disk(path, path).unwrap();
+        assert!(result);
+    }
+
+    #[test]
+    fn test_same_disk_different_paths() {
+        let temp_dir1 = tempfile::tempdir().unwrap();
+        let temp_dir2 = tempfile::tempdir().unwrap();
+
+        let path1 = temp_dir1.path().to_str().unwrap();
+        let path2 = temp_dir2.path().to_str().unwrap();
+
+        let result = same_disk(path1, path2).unwrap();
+        // Since both temporary directories are created in the same file system,
+        // they should be on the same disk in most cases
+        println!("Path1: {}, Path2: {}, Same disk: {}", path1, path2, result);
+        // Test passes if the function doesn't panic - the actual result depends on test environment
+    }
+
+    #[ignore] // FIXME: failed in github actions
+    #[test]
+    fn test_get_drive_stats_default() {
+        let stats = get_drive_stats(0, 0).unwrap();
+        assert_eq!(stats, IOStats::default());
+    }
+}
@@ -0,0 +1,72 @@
+use super::{DiskInfo, IOStats};
+use nix::sys::{stat::stat, statfs::statfs};
+use std::io::Error;
+use std::path::Path;
+
+/// Returns total and free bytes available in a directory, e.g. `/`.
+pub fn get_info(p: impl AsRef<Path>) -> std::io::Result<DiskInfo> {
+    let stat = statfs(p.as_ref())?;
+
+    let bsize = stat.block_size() as u64;
+    let bfree = stat.blocks_free();
+    let bavail = stat.blocks_available();
+    let blocks = stat.blocks();
+
+    let reserved = match bfree.checked_sub(bavail) {
+        Some(reserved) => reserved,
+        None => {
+            return Err(Error::other(format!(
+                "detected f_bavail space ({}) > f_bfree space ({}), fs corruption at ({}). please run 'fsck'",
+                bavail,
+                bfree,
+                p.as_ref().display()
+            )));
+        }
+    };
+
+    let total = match blocks.checked_sub(reserved) {
+        Some(total) => total * bsize,
+        None => {
+            return Err(Error::other(format!(
+                "detected reserved space ({}) > blocks space ({}), fs corruption at ({}). please run 'fsck'",
+                reserved,
+                blocks,
+                p.as_ref().display()
+            )));
+        }
+    };
+
+    let free = bavail * bsize;
+    let used = match total.checked_sub(free) {
+        Some(used) => used,
+        None => {
+            return Err(Error::other(format!(
+                "detected free space ({}) > total drive space ({}), fs corruption at ({}). please run 'fsck'",
+                free,
+                total,
+                p.as_ref().display()
+            )));
+        }
+    };
+
+    Ok(DiskInfo {
+        total,
+        free,
+        used,
+        files: stat.files(),
+        ffree: stat.files_free(),
+        fstype: stat.filesystem_type_name().to_string(),
+        ..Default::default()
+    })
+}
+
+pub fn same_disk(disk1: &str, disk2: &str) -> std::io::Result<bool> {
+    let stat1 = stat(disk1)?;
+    let stat2 = stat(disk2)?;
+
+    Ok(stat1.st_dev == stat2.st_dev)
+}
+
+pub fn get_drive_stats(_major: u32, _minor: u32) -> std::io::Result<IOStats> {
+    Ok(IOStats::default())
+}
@@ -0,0 +1,142 @@
+#![allow(unsafe_code)] // TODO: audit unsafe code
+
+use super::{DiskInfo, IOStats};
+use std::io::{Error, ErrorKind};
+use std::mem;
+use std::os::windows::ffi::OsStrExt;
+use std::path::Path;
+use winapi::shared::minwindef::{DWORD, MAX_PATH};
+use winapi::shared::ntdef::ULARGE_INTEGER;
+use winapi::um::fileapi::{GetDiskFreeSpaceExW, GetDiskFreeSpaceW, GetVolumeInformationW, GetVolumePathNameW};
+use winapi::um::winnt::{LPCWSTR, WCHAR};
+
+/// Returns total and free bytes available in a directory, e.g. `C:\`.
+pub fn get_info(p: impl AsRef<Path>) -> std::io::Result<DiskInfo> {
+    let path_wide: Vec<WCHAR> = p
+        .as_ref()
+        .canonicalize()?
+        .into_os_string()
+        .encode_wide()
+        .chain(std::iter::once(0)) // Null-terminate the string
+        .collect();
+
+    let mut lp_free_bytes_available: ULARGE_INTEGER = unsafe { mem::zeroed() };
+    let mut lp_total_number_of_bytes: ULARGE_INTEGER = unsafe { mem::zeroed() };
+    let mut lp_total_number_of_free_bytes: ULARGE_INTEGER = unsafe { mem::zeroed() };
+
+    let success = unsafe {
+        GetDiskFreeSpaceExW(
+            path_wide.as_ptr(),
+            &mut lp_free_bytes_available,
+            &mut lp_total_number_of_bytes,
+            &mut lp_total_number_of_free_bytes,
+        )
+    };
+    if success == 0 {
+        return Err(Error::last_os_error());
+    }
+
+    let total = unsafe { *lp_total_number_of_bytes.QuadPart() };
+    let free = unsafe { *lp_total_number_of_free_bytes.QuadPart() };
+
+    if free > total {
+        return Err(Error::new(
+            ErrorKind::Other,
+            format!(
+                "detected free space ({}) > total drive space ({}), fs corruption at ({}). please run 'fsck'",
+                free,
+                total,
+                p.as_ref().display()
+            ),
+        ));
+    }
+
+    let mut lp_sectors_per_cluster: DWORD = 0;
+    let mut lp_bytes_per_sector: DWORD = 0;
+    let mut lp_number_of_free_clusters: DWORD = 0;
+    let mut lp_total_number_of_clusters: DWORD = 0;
+
+    let success = unsafe {
+        GetDiskFreeSpaceW(
+            path_wide.as_ptr(),
+            &mut lp_sectors_per_cluster,
+            &mut lp_bytes_per_sector,
+            &mut lp_number_of_free_clusters,
+            &mut lp_total_number_of_clusters,
+        )
+    };
+    if success == 0 {
+        return Err(Error::last_os_error());
+    }
+
+    Ok(DiskInfo {
+        total,
+        free,
+        used: total - free,
+        files: lp_total_number_of_clusters as u64,
+        ffree: lp_number_of_free_clusters as u64,
+        fstype: get_fs_type(&path_wide)?,
+        ..Default::default()
+    })
+}
+
+/// Returns leading volume name.
+fn get_volume_name(v: &[WCHAR]) -> std::io::Result<LPCWSTR> {
+    let volume_name_size: DWORD = MAX_PATH as _;
+    let mut lp_volume_name_buffer: [WCHAR; MAX_PATH] = [0; MAX_PATH];
+
+    let success = unsafe { GetVolumePathNameW(v.as_ptr(), lp_volume_name_buffer.as_mut_ptr(), volume_name_size) };
+
+    if success == 0 {
+        return Err(Error::last_os_error());
+    }
+
+    Ok(lp_volume_name_buffer.as_ptr())
+}
+
+fn utf16_to_string(v: &[WCHAR]) -> String {
+    let len = v.iter().position(|&x| x == 0).unwrap_or(v.len());
+    String::from_utf16_lossy(&v[..len])
+}
+
+/// Returns the filesystem type of the underlying mounted filesystem
+fn get_fs_type(p: &[WCHAR]) -> std::io::Result<String> {
+    let path = get_volume_name(p)?;
+
+    let volume_name_size: DWORD = MAX_PATH as _;
+    let n_file_system_name_size: DWORD = MAX_PATH as _;
+
+    let mut lp_volume_serial_number: DWORD = 0;
+    let mut lp_maximum_component_length: DWORD = 0;
+    let mut lp_file_system_flags: DWORD = 0;
+
+    let mut lp_volume_name_buffer: [WCHAR; MAX_PATH] = [0; MAX_PATH];
+    let mut lp_file_system_name_buffer: [WCHAR; MAX_PATH] = [0; MAX_PATH];
+
+    let success = unsafe {
+        GetVolumeInformationW(
+            path,
+            lp_volume_name_buffer.as_mut_ptr(),
+            volume_name_size,
+            &mut lp_volume_serial_number,
+            &mut lp_maximum_component_length,
+            &mut lp_file_system_flags,
+            lp_file_system_name_buffer.as_mut_ptr(),
+            n_file_system_name_size,
+        )
+    };
+
+    if success == 0 {
+        return Err(Error::last_os_error());
+    }
+
+    Ok(utf16_to_string(&lp_file_system_name_buffer))
+}
+
+pub fn same_disk(_disk1: &str, _disk2: &str) -> std::io::Result<bool> {
+    Ok(false)
+}
+
+pub fn get_drive_stats(_major: u32, _minor: u32) -> std::io::Result<IOStats> {
+    Ok(IOStats::default())
+}