use std::{
ffi::CStr,
mem::MaybeUninit,
os::unix::ffi::{OsStrExt, OsStringExt},
path::Path,
};
use super::{ffi, last_errno, os_error};
use crate::{
Error, Pressure, Result,
disk::{Disk, DiskKind, DiskRaw, ListOptions, Space},
};
pub(super) const PATH_MAX: usize = 1024;
pub(super) fn c_path<'a>(path: &Path, buf: &'a mut [u8; PATH_MAX]) -> Result<&'a CStr> {
let bytes = path.as_os_str().as_bytes();
if bytes.contains(&0) {
return Err(Error::InvalidInput {
what: "disk path",
reason: "it contains a NUL byte",
});
}
if bytes.len() >= buf.len() {
return Err(Error::InvalidInput {
what: "disk path",
reason: "it is longer than the 1 023-byte path limit (MAXPATHLEN)",
});
}
buf[..bytes.len()].copy_from_slice(bytes);
buf[bytes.len()] = 0;
CStr::from_bytes_with_nul(&buf[..=bytes.len()]).map_err(|_| Error::InvalidInput {
what: "disk path",
reason: "it contains a NUL byte",
})
}
pub(super) fn statfs(path: &CStr) -> core::result::Result<ffi::Statfs, i32> {
let mut buf = MaybeUninit::<ffi::Statfs>::zeroed();
let rc = unsafe { ffi::statfs(path.as_ptr(), buf.as_mut_ptr()) };
if rc != 0 {
return Err(last_errno());
}
Ok(unsafe { buf.assume_init() })
}
fn space_of(st: &ffi::Statfs) -> Space {
let block = u64::from(st.bsize);
Space::new(
st.blocks.saturating_mul(block),
st.bfree.saturating_mul(block),
st.bavail.saturating_mul(block),
)
}
pub(crate) fn disk_space(path: &Path) -> Result<Space> {
let mut buf = [0u8; PATH_MAX];
let path = c_path(path, &mut buf)?;
let st = statfs(path).map_err(|code| os_error("disk space", "statfs", code))?;
Ok(space_of(&st))
}
#[cfg(not(target_os = "macos"))]
pub(crate) fn disks(_options: &ListOptions) -> Result<Vec<Disk>> {
Err(super::unsupported("disk list"))
}
#[cfg(target_os = "macos")]
pub(crate) fn disks(options: &ListOptions) -> Result<Vec<Disk>> {
let table = mount_table(options.max_mounts)?;
let mut out = Vec::new();
for st in &table {
let Some(class) = classify(st, options) else {
continue;
};
let space = fresh_space(&mount_point_of(st)).unwrap_or_else(|| space_of(st));
out.push(disk_from(st, class, space));
}
Ok(out)
}
fn mount_point_of(st: &ffi::Statfs) -> std::path::PathBuf {
std::path::PathBuf::from(std::ffi::OsString::from_vec(super::c_array_bytes(
&st.mntonname,
)))
}
fn disk_from(st: &ffi::Statfs, class: DiskKind, space: Space) -> Disk {
Disk {
device: crate::parse::lossy(&super::c_array_bytes(&st.mntfromname), PATH_MAX),
mount_point: mount_point_of(st),
label: volume_label(st, class),
filesystem: crate::parse::lossy(&super::c_array_bytes(&st.fstypename), 16),
kind: medium(st, class),
space: Some(space),
read_only: st.flags & ffi::MNT_RDONLY != 0,
removable: st.flags & ffi::MNT_REMOVABLE != 0,
}
}
pub(crate) fn disk_of(path: &Path) -> Result<Disk> {
const WHAT: &str = "disk of a path";
let mut buf = [0u8; PATH_MAX];
let path = c_path(path, &mut buf)?;
let st = statfs(path).map_err(|code| os_error(WHAT, "statfs", code))?;
let every = ListOptions {
include_network: true,
include_pseudo: true,
include_duplicates: true,
..ListOptions::default()
};
let class = classify(&st, &every).unwrap_or(DiskKind::Unknown);
Ok(disk_from(&st, class, space_of(&st)))
}
#[cfg(target_os = "macos")]
fn medium(st: &ffi::Statfs, class: DiskKind) -> DiskKind {
if class != DiskKind::Unknown {
return class;
}
bsd_name(&super::c_array_bytes(&st.mntfromname))
.and_then(|name| iokit::medium(&name))
.unwrap_or(class)
}
#[cfg(not(target_os = "macos"))]
fn medium(_st: &ffi::Statfs, class: DiskKind) -> DiskKind {
class
}
#[cfg(any(target_os = "macos", test))]
fn bsd_name(device: &[u8]) -> Option<std::ffi::CString> {
let device = device.rsplit(|&b| b == b'@').next()?;
let name = device.strip_prefix(b"/dev/")?;
let valid = !name.is_empty() && name.iter().all(u8::is_ascii_alphanumeric);
if valid {
std::ffi::CString::new(name).ok()
} else {
None
}
}
#[cfg(target_os = "macos")]
fn volume_label(st: &ffi::Statfs, class: DiskKind) -> Option<String> {
if matches!(class, DiskKind::Network | DiskKind::Virtual) {
return None;
}
let mut path = [0u8; PATH_MAX];
let path = c_path(&mount_point_of(st), &mut path).ok()?;
let mut list = ffi::Attrlist {
bitmapcount: ffi::ATTR_BIT_MAP_COUNT,
volattr: ffi::ATTR_VOL_INFO | ffi::ATTR_VOL_NAME,
..ffi::Attrlist::default()
};
let mut buf = [0u8; LABEL_NAME + PATH_MAX];
let rc = unsafe {
ffi::getattrlist(
path.as_ptr(),
(&raw mut list).cast::<core::ffi::c_void>(),
buf.as_mut_ptr().cast::<core::ffi::c_void>(),
buf.len(),
ffi::FSOPT_NOFOLLOW,
)
};
if rc != 0 {
return None;
}
parse_label(&buf)
}
#[cfg(not(target_os = "macos"))]
fn volume_label(_st: &ffi::Statfs, _class: DiskKind) -> Option<String> {
None
}
#[cfg(any(target_os = "macos", test))]
const LABEL_NAME: usize = 12;
#[cfg(any(target_os = "macos", test))]
fn parse_label(buf: &[u8]) -> Option<String> {
const REFERENCE: usize = 4;
let total = usize::try_from(super::u32_at(buf, 0)?).ok()?;
let buf = buf.get(..total)?;
let offset = usize::try_from(super::i32_at(buf, REFERENCE)?).ok()?;
let len = usize::try_from(super::u32_at(buf, REFERENCE + 4)?).ok()?;
let start = REFERENCE.checked_add(offset)?;
let name = buf.get(start..start.checked_add(len)?)?;
let name = name.split(|&b| b == 0).next()?;
let text = crate::parse::lossy(name, PATH_MAX);
(!text.is_empty()).then_some(text)
}
#[cfg(target_os = "macos")]
fn fresh_space(mount_point: &Path) -> Option<Space> {
let mut buf = [0u8; PATH_MAX];
let path = c_path(mount_point, &mut buf).ok()?;
statfs(path).ok().map(|st| space_of(&st))
}
fn classify(st: &ffi::Statfs, options: &ListOptions) -> Option<DiskKind> {
let fstype = super::c_array_bytes(&st.fstypename);
let pseudo = matches!(fstype.as_slice(), b"devfs" | b"autofs");
if pseudo {
return options.include_pseudo.then_some(DiskKind::Virtual);
}
let network = st.flags & ffi::MNT_LOCAL == 0
|| matches!(
fstype.as_slice(),
b"nfs" | b"smbfs" | b"afpfs" | b"webdav" | b"cifs" | b"ftp"
);
if network {
return options.include_network.then_some(DiskKind::Network);
}
if st.flags & ffi::MNT_DONTBROWSE != 0 && !options.include_duplicates {
return None;
}
Some(if st.flags & ffi::MNT_REMOVABLE != 0 {
DiskKind::Removable
} else {
DiskKind::Unknown
})
}
#[cfg(target_os = "macos")]
fn mount_table(max: usize) -> Result<Vec<ffi::Statfs>> {
const WHAT: &str = "disk list";
let too_large = || Error::TooLarge {
what: "mounted filesystems",
limit: max as u64,
};
let mut table: Vec<ffi::Statfs> = Vec::new();
for _ in 0..3 {
let n = unsafe { ffi::getfsstat(core::ptr::null_mut(), 0, ffi::MNT_NOWAIT) };
let n = usize::try_from(n).map_err(|_| os_error(WHAT, "getfsstat", last_errno()))?;
if n > max {
return Err(too_large());
}
let room = n.saturating_add(8).min(max.saturating_add(1));
let bytes = room
.checked_mul(core::mem::size_of::<ffi::Statfs>())
.and_then(|b| core::ffi::c_int::try_from(b).ok())
.ok_or_else(too_large)?;
table.clear();
table.reserve_exact(room);
let got = unsafe { ffi::getfsstat(table.as_mut_ptr(), bytes, ffi::MNT_NOWAIT) };
let got = usize::try_from(got)
.map_err(|_| os_error(WHAT, "getfsstat", last_errno()))?
.min(room);
unsafe { table.set_len(got) };
if got > max {
return Err(too_large());
}
if got < room {
break;
}
}
Ok(table)
}
#[cfg(not(target_os = "macos"))]
pub(crate) fn disk_io_totals() -> Result<DiskRaw> {
Err(super::unsupported("disk I/O"))
}
#[cfg(not(target_os = "macos"))]
pub(crate) fn disk_io_counters() -> Result<Vec<(String, DiskRaw)>> {
Err(super::unsupported("disk I/O"))
}
#[cfg(target_os = "macos")]
pub(crate) fn disk_io_totals() -> Result<DiskRaw> {
let keys = iokit::Keys::new()?;
let mut total = DiskRaw::default();
iokit::for_each_driver(|driver, _| {
if let Some(raw) = iokit::statistics(driver, &keys) {
total.add(&raw);
}
Ok(())
})?;
Ok(total)
}
#[cfg(target_os = "macos")]
pub(crate) fn disk_io_counters() -> Result<Vec<(String, DiskRaw)>> {
let keys = iokit::Keys::new()?;
let mut out = Vec::new();
iokit::for_each_driver(|driver, n| {
if let Some(raw) = iokit::statistics(driver, &keys) {
let name = iokit::bsd_name(driver, &keys).unwrap_or_else(|| format!("disk{n}"));
out.push((name, raw));
}
Ok(())
})?;
Ok(out)
}
pub(crate) fn disk_pressure() -> Result<Option<Pressure>> {
Ok(None)
}
#[cfg(target_os = "macos")]
mod iokit {
use core::time::Duration;
use std::ffi::CStr;
use super::super::{
ffi,
iokit::{Cf, Io, Ref},
kern_error,
};
use crate::{
Error, Result,
disk::{DiskKind, DiskRaw},
};
const WHAT: &str = "disk I/O";
const MAX_DRIVERS: usize = 4_096;
const MAX_DEPTH: usize = 32;
pub(super) struct Keys {
statistics: Cf,
bytes_read: Cf,
bytes_written: Cf,
reads: Cf,
writes: Cf,
read_time: Cf,
write_time: Cf,
bsd_name: Cf,
}
impl Keys {
pub(super) fn new() -> Result<Keys> {
let key = |text| Cf::string(WHAT, text);
Ok(Keys {
statistics: key("Statistics")?,
bytes_read: key("Bytes (Read)")?,
bytes_written: key("Bytes (Write)")?,
reads: key("Operations (Read)")?,
writes: key("Operations (Write)")?,
read_time: key("Total Time (Read)")?,
write_time: key("Total Time (Write)")?,
bsd_name: key("BSD Name")?,
})
}
}
pub(super) fn for_each_driver(mut f: impl FnMut(&Io, usize) -> Result<()>) -> Result<()> {
let matching = unsafe { ffi::IOServiceMatching(c"IOBlockStorageDriver".as_ptr()) };
if matching.is_null() {
return Err(kern_error(WHAT, "IOServiceMatching", 0));
}
let mut iterator: ffi::IoObject = 0;
let kr = unsafe {
ffi::IOServiceGetMatchingServices(
ffi::IO_MAIN_PORT_DEFAULT,
matching,
&raw mut iterator,
)
};
if kr != ffi::KERN_SUCCESS {
return Err(kern_error(WHAT, "IOServiceGetMatchingServices", kr));
}
let Some(iterator) = Io::new(iterator) else {
return Ok(());
};
for n in 0..=MAX_DRIVERS {
let Some(driver) = Io::new(unsafe { ffi::IOIteratorNext(iterator.0) }) else {
return Ok(());
};
if n == MAX_DRIVERS {
break;
}
f(&driver, n)?;
}
Err(Error::TooLarge {
what: "block storage drivers",
limit: MAX_DRIVERS as u64,
})
}
pub(super) fn statistics(driver: &Io, keys: &Keys) -> Option<DiskRaw> {
let stats = driver.property(&keys.statistics)?;
let stats = stats.get();
if !stats.is_dictionary() {
return None;
}
let read_time = number(stats, &keys.read_time);
let write_time = number(stats, &keys.write_time);
Some(DiskRaw {
read: number(stats, &keys.bytes_read),
written: number(stats, &keys.bytes_written),
reads: number(stats, &keys.reads),
writes: number(stats, &keys.writes),
busy: None,
op_time: Some(Duration::from_nanos(read_time.saturating_add(write_time))),
disks: 1,
})
}
fn number(dictionary: Ref<'_>, key: &Cf) -> u64 {
dictionary
.value(key)
.and_then(Ref::int)
.and_then(|n| u64::try_from(n).ok())
.unwrap_or(0)
}
pub(super) fn bsd_name(driver: &Io, keys: &Keys) -> Option<String> {
let media = driver.child()?;
let name = media.property(&keys.bsd_name)?;
let mut buf = [0u8; 64];
let text = crate::parse::lossy(name.get().text(&mut buf)?, 64);
(!text.is_empty()).then_some(text)
}
pub(super) fn medium(name: &CStr) -> Option<DiskKind> {
let characteristics = Cf::string(WHAT, "Device Characteristics").ok()?;
let medium_type = Cf::string(WHAT, "Medium Type").ok()?;
let mut entry = Io::bsd_device(name)?;
for _ in 0..MAX_DEPTH {
entry = entry.parent()?;
if let Some(found) = entry.property(&characteristics) {
let mut buf = [0u8; 32];
let value = found.get().value(&medium_type)?.text(&mut buf)?;
return super::medium_kind(value);
}
}
None
}
}
#[cfg(any(target_os = "macos", test))]
fn medium_kind(value: &[u8]) -> Option<DiskKind> {
match value {
b"Solid State" => Some(DiskKind::Ssd),
b"Rotational" => Some(DiskKind::Hdd),
_ => None,
}
}
#[cfg(test)]
mod tests {
use std::path::PathBuf;
use super::*;
#[test]
fn test_disk_apple_c_path_bounds_and_nul() {
let mut buf = [0u8; PATH_MAX];
assert_eq!(c_path(Path::new("/tmp"), &mut buf).unwrap(), c"/tmp");
let long = PathBuf::from("a".repeat(PATH_MAX));
assert!(matches!(
c_path(&long, &mut buf),
Err(Error::InvalidInput { .. })
));
let nul = PathBuf::from(std::ffi::OsStr::from_bytes(b"/a\0b"));
assert!(matches!(
c_path(&nul, &mut buf),
Err(Error::InvalidInput { .. })
));
}
#[test]
fn test_disk_apple_space_multiplies_blocks() {
let mut st: ffi::Statfs = unsafe { MaybeUninit::zeroed().assume_init() };
st.bsize = 4096;
st.blocks = 1000;
st.bfree = 400;
st.bavail = 300;
let s = space_of(&st);
assert_eq!(
(s.total.raw(), s.free.raw(), s.available.raw()),
(4_096_000, 1_638_400, 1_228_800)
);
st.blocks = u64::MAX;
assert_eq!(space_of(&st).total.raw(), u64::MAX);
}
#[test]
fn test_disk_apple_bsd_name_from_device() {
assert_eq!(
bsd_name(b"/dev/disk3s1s1").unwrap().as_c_str(),
c"disk3s1s1"
);
let snapshot = bsd_name(b"com.apple.os.update-0A1B@/dev/disk1s5");
assert_eq!(snapshot.unwrap().as_c_str(), c"disk1s5");
for device in [
&b"map auto_home"[..],
b"devfs",
b"//user@server/share",
b"/dev/",
b"/dev/../etc",
b"/dev/disk0 s1",
] {
assert_eq!(bsd_name(device), None, "{device:?}");
}
}
#[test]
fn test_disk_apple_medium_values() {
assert_eq!(medium_kind(b"Solid State"), Some(DiskKind::Ssd));
assert_eq!(medium_kind(b"Rotational"), Some(DiskKind::Hdd));
assert_eq!(medium_kind(b"Tape"), None);
assert_eq!(medium_kind(b""), None);
}
fn label_answer(name: &[u8]) -> Vec<u8> {
let mut buf = Vec::new();
let total = (LABEL_NAME + name.len() + 1) as u32;
buf.extend(total.to_ne_bytes());
buf.extend(8i32.to_ne_bytes());
buf.extend((name.len() as u32 + 1).to_ne_bytes());
buf.extend(name);
buf.push(0);
buf
}
#[test]
fn test_disk_apple_label_from_attribute_buffer() {
let mut buf = label_answer("Macintosh HD".as_bytes());
assert_eq!(parse_label(&buf).as_deref(), Some("Macintosh HD"));
buf.resize(1036, 0);
assert_eq!(parse_label(&buf).as_deref(), Some("Macintosh HD"));
assert_eq!(
parse_label(&label_answer("\u{e9}t\u{e9}".as_bytes())).as_deref(),
Some("\u{e9}t\u{e9}")
);
assert_eq!(parse_label(&label_answer(b"")), None, "an unnamed volume");
}
#[test]
fn test_disk_apple_label_rejects_bad_offsets() {
let good = label_answer(b"Data");
assert_eq!(parse_label(&good[..6]), None);
assert_eq!(parse_label(&[]), None);
let mut long = good.clone();
long[..4].copy_from_slice(&5000u32.to_ne_bytes());
assert_eq!(parse_label(&long), None);
let mut negative = good.clone();
negative[4..8].copy_from_slice(&(-8i32).to_ne_bytes());
assert_eq!(parse_label(&negative), None);
let mut past = good.clone();
past[4..8].copy_from_slice(&4000i32.to_ne_bytes());
assert_eq!(parse_label(&past), None);
let mut huge = good;
huge[8..12].copy_from_slice(&u32::MAX.to_ne_bytes());
assert_eq!(parse_label(&huge), None);
}
fn mount(fstype: &[u8], flags: u32) -> ffi::Statfs {
let mut st: ffi::Statfs = unsafe { MaybeUninit::zeroed().assume_init() };
for (dst, &src) in st.fstypename.iter_mut().zip(fstype) {
*dst = src.cast_signed();
}
st.flags = flags;
st
}
#[test]
fn test_disk_apple_classify_by_type_and_flags() {
use ffi::{MNT_DONTBROWSE, MNT_LOCAL, MNT_REMOVABLE};
let default = ListOptions::default();
let all = ListOptions {
include_network: true,
include_pseudo: true,
include_duplicates: true,
..ListOptions::default()
};
let root = mount(b"apfs", MNT_LOCAL);
assert_eq!(classify(&root, &default), Some(DiskKind::Unknown));
let usb = mount(b"msdos", MNT_LOCAL | MNT_REMOVABLE);
assert_eq!(classify(&usb, &default), Some(DiskKind::Removable));
let data = mount(b"apfs", MNT_LOCAL | MNT_DONTBROWSE);
assert_eq!(classify(&data, &default), None);
assert_eq!(classify(&data, &all), Some(DiskKind::Unknown));
let nfs = mount(b"nfs", 0);
assert_eq!(classify(&nfs, &default), None);
assert_eq!(classify(&nfs, &all), Some(DiskKind::Network));
let smb = mount(b"smbfs", MNT_LOCAL);
assert_eq!(classify(&smb, &all), Some(DiskKind::Network));
let auto = mount(b"autofs", MNT_DONTBROWSE);
assert_eq!(classify(&auto, &default), None);
assert_eq!(classify(&auto, &all), Some(DiskKind::Virtual));
let dev = mount(b"devfs", MNT_LOCAL | MNT_DONTBROWSE);
assert_eq!(classify(&dev, &all), Some(DiskKind::Virtual));
}
#[cfg(target_os = "macos")]
#[test]
fn test_disk_apple_live_list_and_io() {
let list = disks(&ListOptions::default()).unwrap();
assert!(list.iter().any(|d| d.mount_point == Path::new("/")));
for d in &list {
assert!(!d.filesystem.is_empty() && !d.device.is_empty(), "{d:?}");
assert_ne!(d.kind, DiskKind::Network);
}
let tight = ListOptions {
max_mounts: 0,
..ListOptions::default()
};
assert!(matches!(disks(&tight), Err(Error::TooLarge { .. })));
let total = disk_io_totals().unwrap();
let each = disk_io_counters().unwrap();
let sum: u64 = each.iter().map(|(_, r)| r.read).sum();
assert!(sum <= disk_io_totals().unwrap().read);
assert!(total.read <= disk_io_totals().unwrap().read);
for (name, _) in &each {
assert!(name.starts_with("disk"), "{name}");
}
}
#[cfg(target_os = "macos")]
#[test]
fn test_disk_apple_live_disk_of() {
let root = disk_of(Path::new("/")).unwrap();
assert_eq!(root.mount_point, Path::new("/"));
assert!(root.device.starts_with("/dev/"), "{root:?}");
assert!(root.space.is_some_and(|s| s.total.raw() > 0));
let listed = disks(&ListOptions::default()).unwrap();
let listed = listed.iter().find(|d| d.mount_point == Path::new("/"));
assert_eq!(root.kind, listed.unwrap().kind);
let dev = disk_of(Path::new("/dev")).unwrap();
assert_eq!((dev.kind, dev.label), (DiskKind::Virtual, None));
assert!(matches!(
disk_of(Path::new("/definitely/not/here/sys-lib")),
Err(Error::NotFound { .. })
));
}
#[test]
fn test_disk_apple_live_space() {
let s = disk_space(Path::new("/")).unwrap();
assert!(s.total.raw() > 0 && s.available <= s.free && s.free <= s.total);
assert!(matches!(
disk_space(Path::new("/definitely/not/here/sys-lib")),
Err(Error::NotFound { .. })
));
assert_eq!(disk_pressure().unwrap(), None);
}
}