/rust/registry/src/index.crates.io-1949cf8c6b5b557f/nix-0.30.1/src/sys/statvfs.rs

Source
//! Get filesystem statistics
//!
//! See [the man pages](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fstatvfs.html)
//! for more details.
use std::mem;
use std::os::unix::io::{AsFd, AsRawFd};

use libc::{self, c_ulong};

use crate::{errno::Errno, NixPath, Result};

#[cfg(not(target_os = "redox"))]
libc_bitflags!(
    /// File system mount Flags
    #[derive(Default)]
    pub struct FsFlags: c_ulong {
        /// Read Only
        #[cfg(not(target_os = "haiku"))]
        ST_RDONLY;
        /// Do not allow the set-uid bits to have an effect
        #[cfg(not(target_os = "haiku"))]
        ST_NOSUID;
        /// Do not interpret character or block-special devices
        #[cfg(linux_android)]
        ST_NODEV;
        /// Do not allow execution of binaries on the filesystem
        #[cfg(linux_android)]
        ST_NOEXEC;
        /// All IO should be done synchronously
        #[cfg(linux_android)]
        ST_SYNCHRONOUS;
        /// Allow mandatory locks on the filesystem
        #[cfg(linux_android)]
        ST_MANDLOCK;
        /// Write on file/directory/symlink
        #[cfg(target_os = "linux")]
        ST_WRITE;
        /// Append-only file
        #[cfg(target_os = "linux")]
        ST_APPEND;
        /// Immutable file
        #[cfg(target_os = "linux")]
        ST_IMMUTABLE;
        /// Do not update access times on files
        #[cfg(linux_android)]
        ST_NOATIME;
        /// Do not update access times on files
        #[cfg(linux_android)]
        ST_NODIRATIME;
        /// Update access time relative to modify/change time
        #[cfg(any(target_os = "android", all(target_os = "linux", not(target_env = "musl"), not(target_env = "ohos"))))]
        ST_RELATIME;
    }
);

/// Wrapper around the POSIX `statvfs` struct
///
/// For more information see the [`statvfs(3)` man pages](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_statvfs.h.html).
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub struct Statvfs(libc::statvfs);

impl Statvfs {
    /// get the file system block size
    pub fn block_size(&self) -> c_ulong {
        self.0.f_bsize
    }

    /// Get the fundamental file system block size
    pub fn fragment_size(&self) -> c_ulong {
        self.0.f_frsize
    }

    /// Get the number of blocks.
    ///
    /// Units are in units of `fragment_size()`
    pub fn blocks(&self) -> libc::fsblkcnt_t {
        self.0.f_blocks
    }

    /// Get the number of free blocks in the file system
    pub fn blocks_free(&self) -> libc::fsblkcnt_t {
        self.0.f_bfree
    }

    /// Get the number of free blocks for unprivileged users
    pub fn blocks_available(&self) -> libc::fsblkcnt_t {
        self.0.f_bavail
    }

    /// Get the total number of file inodes
    pub fn files(&self) -> libc::fsfilcnt_t {
        self.0.f_files
    }

    /// Get the number of free file inodes
    pub fn files_free(&self) -> libc::fsfilcnt_t {
        self.0.f_ffree
    }

    /// Get the number of free file inodes for unprivileged users
    pub fn files_available(&self) -> libc::fsfilcnt_t {
        self.0.f_favail
    }

    /// Get the file system id
    #[cfg(not(target_os = "hurd"))]
    pub fn filesystem_id(&self) -> c_ulong {
        self.0.f_fsid
    }
    /// Get the file system id
    #[cfg(target_os = "hurd")]
    pub fn filesystem_id(&self) -> u64 {
        self.0.f_fsid
    }

    /// Get the mount flags
    #[cfg(not(target_os = "redox"))]
    pub fn flags(&self) -> FsFlags {
        FsFlags::from_bits_truncate(self.0.f_flag)
    }

    /// Get the maximum filename length
    pub fn name_max(&self) -> c_ulong {
        self.0.f_namemax
    }
}

/// Return a `Statvfs` object with information about the `path`
pub fn statvfs<P: ?Sized + NixPath>(path: &P) -> Result<Statvfs> {
    unsafe {
        Errno::clear();
        let mut stat = mem::MaybeUninit::<libc::statvfs>::uninit();
        let res = path.with_nix_path(|path| {
            libc::statvfs(path.as_ptr(), stat.as_mut_ptr())
        })?;

        Errno::result(res).map(|_| Statvfs(stat.assume_init()))
    }
}

/// Return a `Statvfs` object with information about `fd`
pub fn fstatvfs<Fd: AsFd>(fd: Fd) -> Result<Statvfs> {
    unsafe {
        Errno::clear();
        let mut stat = mem::MaybeUninit::<libc::statvfs>::uninit();
        Errno::result(libc::fstatvfs(fd.as_fd().as_raw_fd(), stat.as_mut_ptr()))
            .map(|_| Statvfs(stat.assume_init()))
    }
}

Line	Count	Source
1		//! Get filesystem statistics
2		//!
3		//! See [the man pages](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fstatvfs.html)
4		//! for more details.
5		use std::mem;
6		use std::os::unix::io::{AsFd, AsRawFd};
7
8		use libc::{self, c_ulong};
9
10		use crate::{errno::Errno, NixPath, Result};
11
12		#[cfg(not(target_os = "redox"))]
13		libc_bitflags!(
14		/// File system mount Flags
15		#[derive(Default)]
16		pub struct FsFlags: c_ulong {
17		/// Read Only
18		#[cfg(not(target_os = "haiku"))]
19		ST_RDONLY;
20		/// Do not allow the set-uid bits to have an effect
21		#[cfg(not(target_os = "haiku"))]
22		ST_NOSUID;
23		/// Do not interpret character or block-special devices
24		#[cfg(linux_android)]
25		ST_NODEV;
26		/// Do not allow execution of binaries on the filesystem
27		#[cfg(linux_android)]
28		ST_NOEXEC;
29		/// All IO should be done synchronously
30		#[cfg(linux_android)]
31		ST_SYNCHRONOUS;
32		/// Allow mandatory locks on the filesystem
33		#[cfg(linux_android)]
34		ST_MANDLOCK;
35		/// Write on file/directory/symlink
36		#[cfg(target_os = "linux")]
37		ST_WRITE;
38		/// Append-only file
39		#[cfg(target_os = "linux")]
40		ST_APPEND;
41		/// Immutable file
42		#[cfg(target_os = "linux")]
43		ST_IMMUTABLE;
44		/// Do not update access times on files
45		#[cfg(linux_android)]
46		ST_NOATIME;
47		/// Do not update access times on files
48		#[cfg(linux_android)]
49		ST_NODIRATIME;
50		/// Update access time relative to modify/change time
51		#[cfg(any(target_os = "android", all(target_os = "linux", not(target_env = "musl"), not(target_env = "ohos"))))]
52		ST_RELATIME;
53		}
54		);
55
56		/// Wrapper around the POSIX `statvfs` struct
57		///
58		/// For more information see the [`statvfs(3)` man pages](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_statvfs.h.html).
59		#[repr(transparent)]
60		#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
61		pub struct Statvfs(libc::statvfs);
62
63		impl Statvfs {
64		/// get the file system block size
65	0	pub fn block_size(&self) -> c_ulong {
66	0	self.0.f_bsize
67	0	}
68
69		/// Get the fundamental file system block size
70	0	pub fn fragment_size(&self) -> c_ulong {
71	0	self.0.f_frsize
72	0	}
73
74		/// Get the number of blocks.
75		///
76		/// Units are in units of `fragment_size()`
77	0	pub fn blocks(&self) -> libc::fsblkcnt_t {
78	0	self.0.f_blocks
79	0	}
80
81		/// Get the number of free blocks in the file system
82	0	pub fn blocks_free(&self) -> libc::fsblkcnt_t {
83	0	self.0.f_bfree
84	0	}
85
86		/// Get the number of free blocks for unprivileged users
87	0	pub fn blocks_available(&self) -> libc::fsblkcnt_t {
88	0	self.0.f_bavail
89	0	}
90
91		/// Get the total number of file inodes
92	0	pub fn files(&self) -> libc::fsfilcnt_t {
93	0	self.0.f_files
94	0	}
95
96		/// Get the number of free file inodes
97	0	pub fn files_free(&self) -> libc::fsfilcnt_t {
98	0	self.0.f_ffree
99	0	}
100
101		/// Get the number of free file inodes for unprivileged users
102	0	pub fn files_available(&self) -> libc::fsfilcnt_t {
103	0	self.0.f_favail
104	0	}
105
106		/// Get the file system id
107		#[cfg(not(target_os = "hurd"))]
108	0	pub fn filesystem_id(&self) -> c_ulong {
109	0	self.0.f_fsid
110	0	}
111		/// Get the file system id
112		#[cfg(target_os = "hurd")]
113		pub fn filesystem_id(&self) -> u64 {
114		self.0.f_fsid
115		}
116
117		/// Get the mount flags
118		#[cfg(not(target_os = "redox"))]
119	0	pub fn flags(&self) -> FsFlags {
120	0	FsFlags::from_bits_truncate(self.0.f_flag)
121	0	}
122
123		/// Get the maximum filename length
124	0	pub fn name_max(&self) -> c_ulong {
125	0	self.0.f_namemax
126	0	}
127		}
128
129		/// Return a `Statvfs` object with information about the `path`
130	0	pub fn statvfs<P: ?Sized + NixPath>(path: &P) -> Result<Statvfs> {
131		unsafe {
132	0	Errno::clear();
133	0	let mut stat = mem::MaybeUninit::<libc::statvfs>::uninit();
134	0	let res = path.with_nix_path(\|path\| {
135	0	libc::statvfs(path.as_ptr(), stat.as_mut_ptr())
136	0	})?;
137
138	0	Errno::result(res).map(\|_\| Statvfs(stat.assume_init()))
139		}
140	0	}
141
142		/// Return a `Statvfs` object with information about `fd`
143	0	pub fn fstatvfs<Fd: AsFd>(fd: Fd) -> Result<Statvfs> {
144		unsafe {
145	0	Errno::clear();
146	0	let mut stat = mem::MaybeUninit::<libc::statvfs>::uninit();
147	0	Errno::result(libc::fstatvfs(fd.as_fd().as_raw_fd(), stat.as_mut_ptr()))
148	0	.map(\|_\| Statvfs(stat.assume_init()))
149		}
150	0	}

Coverage Report

Created: 2025-10-29 07:05