Cross platform get_info

Signed-off-by: junxiang Mu <1948535941@qq.com>
2026-08-10 07:06:53 +00:00 · 2024-10-22 14:31:28 +08:00
parent 9ff243a7a9
commit 49593dd77d
12 changed files with 281 additions and 10 deletions
@@ -0,0 +1,84 @@
+use nix::sys::{
+    stat::{major, minor, stat},
+    statfs::{statfs, FsType},
+};
+
+use crate::{
+    disk::Info,
+    error::{Error, Result},
+};
+
+use lazy_static::lazy_static;
+use std::collections::HashMap;
+
+lazy_static! {
+    static ref FS_TYPE_TO_STRING_MAP: HashMap<&'static str, &'static str> = {
+        let mut m = HashMap::new();
+        m.insert("1021994", "TMPFS");
+        m.insert("137d", "EXT");
+        m.insert("4244", "HFS");
+        m.insert("4d44", "MSDOS");
+        m.insert("52654973", "REISERFS");
+        m.insert("5346544e", "NTFS");
+        m.insert("58465342", "XFS");
+        m.insert("61756673", "AUFS");
+        m.insert("6969", "NFS");
+        m.insert("ef51", "EXT2OLD");
+        m.insert("ef53", "EXT4");
+        m.insert("f15f", "ecryptfs");
+        m.insert("794c7630", "overlayfs");
+        m.insert("2fc12fc1", "zfs");
+        m.insert("ff534d42", "cifs");
+        m.insert("53464846", "wslfs");
+        m
+    };
+}
+
+fn get_fs_type(ftype: FsType) -> String {
+    let binding = format!("{:?}", ftype);
+    let fs_type_hex = binding.as_str();
+    match FS_TYPE_TO_STRING_MAP.get(fs_type_hex) {
+        Some(fs_type_string) => fs_type_string.to_string(),
+        None => "UNKNOWN".to_string(),
+    }
+}
+
+pub fn get_info(path: &str, first_time: bool) -> Result<Info> {
+    let statfs = statfs(path)?;
+    let reserved_blocks = statfs.blocks_free() - statfs.blocks_available();
+    let mut info = Info {
+        total: statfs.block_size() as u64 * (statfs.blocks() - reserved_blocks),
+        free: statfs.blocks() as u64 * statfs.blocks_available(),
+        files: statfs.files(),
+        ffree: statfs.files_free(),
+        fstype: get_fs_type(statfs.filesystem_type()),
+        ..Default::default()
+    };
+
+    let stat = stat(path)?;
+    let dev_id = stat.st_dev as u64;
+    info.major = major(dev_id);
+    info.minor = minor(dev_id);
+
+    if info.free > info.total {
+        return Err(Error::from_string(format!(
+            "detected free space {} > total drive space {}, fs corruption at {}. please run 'fsck'",
+            info.free, info.total, path
+        )));
+    }
+
+    info.used = info.total - info.free;
+
+    if first_time {
+        // todo
+    }
+
+    Ok(info)
+}
+
+pub fn same_disk(disk1: &str, disk2: &str) -> Result<bool> {
+    let stat1 = stat(disk1)?;
+    let stat2 = stat(disk2)?;
+
+    Ok(stat1.st_dev == stat2.st_dev)
+}
@@ -0,0 +1,14 @@
+#[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_info;
+pub use linux::same_disk;
+#[cfg(all(unix, not(target_os = "linux")))]
+pub use unix::get_info;
+#[cfg(target_os = "windows")]
+pub use windows::get_info;
@@ -0,0 +1,77 @@
+use crate::disk::Info;
+use nix::sys::{statfs::statfs, stat::stat};
+use std::io::{Error, ErrorKind};
+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<Info> {
+    let stat = statfs(p.as_ref())?;
+
+    let bsize = stat.block_size() as u64;
+    let bfree = stat.blocks_free() as u64;
+    let bavail = stat.blocks_available() as u64;
+    let blocks = stat.blocks() as u64;
+
+    let reserved = match bfree.checked_sub(bavail) {
+        Some(reserved) => reserved,
+        None => {
+            return Err(Error::new(
+                ErrorKind::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::new(
+                ErrorKind::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::new(
+                ErrorKind::Other,
+                format!(
+                    "detected free space ({}) > total drive space ({}), fs corruption at ({}). please run 'fsck'",
+                    free,
+                    total,
+                    p.as_ref().display()
+                ),
+            ))
+        }
+    };
+
+    Ok(Info {
+        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) -> Result<bool> {
+    let stat1 = stat(disk1)?;
+    let stat2 = stat(disk2)?;
+
+    Ok(stat1.st_dev == stat2.st_dev)
+}
@@ -0,0 +1,136 @@
+use crate::disk::Info;
+use std::io::{Error, ErrorKind, Result};
+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>) -> Result<Info> {
+    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(Info {
+        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]) -> 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]) -> 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) -> Result<bool> {
+    Ok(false)
+}