use std::path::Path;
use std::str::FromStr;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum StorageClass {
Hdd,
Ssd,
Unknown,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum StoragePreference {
#[default]
Auto,
Hdd,
Ssd,
}
impl FromStr for StoragePreference {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s.trim().to_ascii_lowercase().as_str() {
"auto" => Ok(Self::Auto),
"hdd" => Ok(Self::Hdd),
"ssd" => Ok(Self::Ssd),
other => Err(format!(
"invalid storage '{other}' (expected auto, hdd, or ssd)"
)),
}
}
}
impl std::fmt::Display for StoragePreference {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Auto => f.write_str("auto"),
Self::Hdd => f.write_str("hdd"),
Self::Ssd => f.write_str("ssd"),
}
}
}
#[cfg(test)]
impl From<StorageClass> for StoragePreference {
fn from(class: StorageClass) -> Self {
match class {
StorageClass::Hdd => Self::Hdd,
StorageClass::Ssd => Self::Ssd,
StorageClass::Unknown => Self::Auto,
}
}
}
#[must_use]
pub fn detect_storage(path: &Path) -> StorageClass {
#[cfg(target_os = "linux")]
{
use std::os::unix::fs::MetadataExt;
let Ok(meta) = std::fs::metadata(path) else {
return StorageClass::Unknown;
};
let dev = meta.dev();
let sys_dev =
Path::new("/sys/dev/block").join(format!("{}:{}", dev_major(dev), dev_minor(dev)));
classify_sysfs_device(&sys_dev)
}
#[cfg(target_os = "windows")]
{
detect_storage_windows(path)
}
#[cfg(target_os = "macos")]
{
detect_storage_macos(path)
}
#[cfg(not(any(target_os = "linux", target_os = "windows", target_os = "macos")))]
{
let _ = path;
StorageClass::Unknown
}
}
#[cfg(target_os = "macos")]
fn detect_storage_macos(path: &Path) -> StorageClass {
let output = std::process::Command::new("diskutil")
.arg("info")
.arg(path)
.output();
match output {
Ok(out) if out.status.success() => {
parse_diskutil_class(&String::from_utf8_lossy(&out.stdout))
.unwrap_or(StorageClass::Unknown)
}
_ => StorageClass::Unknown,
}
}
#[cfg(any(target_os = "macos", test))]
fn parse_diskutil_class(text: &str) -> Option<StorageClass> {
for line in text.lines() {
if let Some(value) = line.trim().strip_prefix("Solid State:") {
return match value.trim() {
"Yes" => Some(StorageClass::Ssd),
"No" => Some(StorageClass::Hdd),
_ => None,
};
}
}
for line in text.lines() {
if let Some(value) = line.trim().strip_prefix("Media Type:") {
return match value.trim() {
"SSD" => Some(StorageClass::Ssd),
"HDD" => Some(StorageClass::Hdd),
_ => None,
};
}
}
None
}
#[cfg(target_os = "windows")]
use windows_sys::Win32::Foundation::HANDLE;
#[cfg(target_os = "windows")]
#[allow(clippy::cast_possible_truncation)]
fn detect_storage_windows(path: &Path) -> StorageClass {
use std::os::windows::ffi::OsStrExt;
use windows_sys::Win32::Foundation::{CloseHandle, INVALID_HANDLE_VALUE};
use windows_sys::Win32::Storage::FileSystem::{
CreateFileW, FILE_SHARE_READ, FILE_SHARE_WRITE, GetVolumeNameForVolumeMountPointW,
GetVolumePathNameW, OPEN_EXISTING,
};
let path_wide: Vec<u16> = path.as_os_str().encode_wide().chain(Some(0)).collect();
let mut mount_point = vec![0u16; 512];
let ok = unsafe {
GetVolumePathNameW(
path_wide.as_ptr(),
mount_point.as_mut_ptr(),
mount_point.len() as u32,
)
};
if ok == 0 {
return StorageClass::Unknown;
}
let mut volume_guid = vec![0u16; 512];
let ok = unsafe {
GetVolumeNameForVolumeMountPointW(
mount_point.as_ptr(),
volume_guid.as_mut_ptr(),
volume_guid.len() as u32,
)
};
if ok == 0 {
return StorageClass::Unknown;
}
let handle = unsafe {
CreateFileW(
volume_guid.as_ptr(),
0, FILE_SHARE_READ | FILE_SHARE_WRITE,
std::ptr::null(),
OPEN_EXISTING,
0,
std::ptr::null_mut(),
)
};
if handle == INVALID_HANDLE_VALUE {
return StorageClass::Unknown;
}
let class = match query_seek_penalty(handle) {
Some(true) => StorageClass::Hdd,
Some(false) => StorageClass::Ssd,
None => StorageClass::Unknown,
};
unsafe { CloseHandle(handle) };
class
}
#[cfg(target_os = "windows")]
#[allow(clippy::cast_possible_truncation)]
fn query_seek_penalty(handle: HANDLE) -> Option<bool> {
use windows_sys::Win32::System::IO::DeviceIoControl;
use windows_sys::Win32::System::Ioctl::{
DEVICE_SEEK_PENALTY_DESCRIPTOR, IOCTL_STORAGE_QUERY_PROPERTY, PropertyStandardQuery,
STORAGE_PROPERTY_QUERY, StorageDeviceSeekPenaltyProperty,
};
let query = STORAGE_PROPERTY_QUERY {
PropertyId: StorageDeviceSeekPenaltyProperty,
QueryType: PropertyStandardQuery,
AdditionalParameters: [0],
};
let mut descriptor = DEVICE_SEEK_PENALTY_DESCRIPTOR::default();
let mut bytes_returned = 0u32;
let ok = unsafe {
DeviceIoControl(
handle,
IOCTL_STORAGE_QUERY_PROPERTY,
(&raw const query).cast::<core::ffi::c_void>(),
core::mem::size_of::<STORAGE_PROPERTY_QUERY>() as u32,
(&raw mut descriptor).cast::<core::ffi::c_void>(),
core::mem::size_of::<DEVICE_SEEK_PENALTY_DESCRIPTOR>() as u32,
&raw mut bytes_returned,
std::ptr::null_mut(),
)
};
if ok == 0 {
return None;
}
Some(descriptor.IncursSeekPenalty)
}
#[cfg(target_os = "linux")]
pub(crate) fn classify_sysfs_device(sys_dev: &Path) -> StorageClass {
if let Ok(rotational) = std::fs::read_to_string(sys_dev.join("queue/rotational")) {
return match rotational.trim() {
"1" => StorageClass::Hdd,
"0" => StorageClass::Ssd,
_ => StorageClass::Unknown,
};
}
let Ok(slaves) = std::fs::read_dir(sys_dev.join("slaves")) else {
return StorageClass::Unknown;
};
let mut seen = false;
for entry in slaves.flatten() {
seen = true;
if classify_sysfs_device(&entry.path()) == StorageClass::Hdd {
return StorageClass::Hdd;
}
}
if seen {
StorageClass::Ssd
} else {
StorageClass::Unknown
}
}
#[cfg(target_os = "linux")]
#[expect(clippy::cast_possible_truncation)]
fn dev_major(dev: u64) -> u32 {
(((dev >> 8) & 0xfff) | ((dev >> 32) & !0xfff)) as u32
}
#[cfg(target_os = "linux")]
#[expect(clippy::cast_possible_truncation)]
fn dev_minor(dev: u64) -> u32 {
((dev & 0xff) | ((dev >> 12) & !0xff)) as u32
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn detect_storage_missing_path_is_unknown() {
assert_eq!(
detect_storage(Path::new("/nonexistent/cp2-storage-test")),
StorageClass::Unknown
);
}
#[test]
fn storage_preference_parses() {
assert_eq!(
"auto".parse::<StoragePreference>().unwrap(),
StoragePreference::Auto
);
assert_eq!(
"HDD".parse::<StoragePreference>().unwrap(),
StoragePreference::Hdd
);
assert_eq!(
"ssd".parse::<StoragePreference>().unwrap(),
StoragePreference::Ssd
);
assert!("raid".parse::<StoragePreference>().is_err());
}
#[test]
fn storage_class_maps_to_preference() {
assert_eq!(
StoragePreference::from(StorageClass::Hdd),
StoragePreference::Hdd
);
assert_eq!(
StoragePreference::from(StorageClass::Ssd),
StoragePreference::Ssd
);
assert_eq!(
StoragePreference::from(StorageClass::Unknown),
StoragePreference::Auto
);
}
#[test]
fn diskutil_solid_state_yes_is_ssd() {
let out = "\
Device Identifier: disk3s1s1
Device Node: /dev/disk3s1s1
Solid State: Yes
Media Type: SSD
";
assert_eq!(parse_diskutil_class(out), Some(StorageClass::Ssd));
}
#[test]
fn diskutil_solid_state_no_is_hdd() {
let out = "\
Solid State: No
";
assert_eq!(parse_diskutil_class(out), Some(StorageClass::Hdd));
}
#[test]
fn diskutil_media_type_fallback() {
assert_eq!(
parse_diskutil_class(" Media Type: SSD\n"),
Some(StorageClass::Ssd)
);
assert_eq!(
parse_diskutil_class(" Media Type: HDD\n"),
Some(StorageClass::Hdd)
);
}
#[test]
fn diskutil_solid_state_wins_over_media_type() {
let out = "Solid State: No\nMedia Type: SSD\n";
assert_eq!(parse_diskutil_class(out), Some(StorageClass::Hdd));
}
#[test]
fn diskutil_unrecognized_output_is_none() {
assert_eq!(parse_diskutil_class("diskutil: No such file"), None);
assert_eq!(parse_diskutil_class(""), None);
assert_eq!(parse_diskutil_class("Solid State: Maybe\n"), None);
}
#[cfg(target_os = "linux")]
mod sysfs_tests {
use super::*;
fn sysfs(dir: &std::path::Path, dev: &str) -> std::path::PathBuf {
let root = dir.join("sys").join("dev").join("block").join(dev);
std::fs::create_dir_all(root.join("queue")).unwrap();
root
}
fn mark_rotational(dev: &std::path::Path, value: &str) {
std::fs::create_dir_all(dev.join("queue")).unwrap();
std::fs::write(dev.join("queue/rotational"), value).unwrap();
}
fn add_slave(dev: &std::path::Path, name: &str) -> std::path::PathBuf {
let slave = dev.join("slaves").join(name);
std::fs::create_dir_all(&slave).unwrap();
slave
}
#[test]
fn rotational_one_is_hdd() {
let dir = tempfile::tempdir().unwrap();
let dev = sysfs(dir.path(), "8:0");
std::fs::write(dev.join("queue/rotational"), "1").unwrap();
assert_eq!(classify_sysfs_device(&dev), StorageClass::Hdd);
}
#[test]
fn rotational_zero_is_ssd() {
let dir = tempfile::tempdir().unwrap();
let dev = sysfs(dir.path(), "259:0");
std::fs::write(dev.join("queue/rotational"), "0").unwrap();
assert_eq!(classify_sysfs_device(&dev), StorageClass::Ssd);
}
#[test]
fn unrecognized_rotational_is_unknown() {
let dir = tempfile::tempdir().unwrap();
let dev = sysfs(dir.path(), "8:0");
std::fs::write(dev.join("queue/rotational"), "").unwrap();
assert_eq!(classify_sysfs_device(&dev), StorageClass::Unknown);
}
#[test]
fn rotational_trailing_newline_is_hdd() {
let dir = tempfile::tempdir().unwrap();
let dev = sysfs(dir.path(), "8:16");
std::fs::write(dev.join("queue/rotational"), "1\n").unwrap();
assert_eq!(classify_sysfs_device(&dev), StorageClass::Hdd);
}
#[test]
fn missing_device_is_unknown() {
let dir = tempfile::tempdir().unwrap();
let dev = sysfs(dir.path(), "8:0");
assert_eq!(classify_sysfs_device(&dev), StorageClass::Unknown);
}
#[test]
fn empty_slaves_is_unknown() {
let dir = tempfile::tempdir().unwrap();
let dev = sysfs(dir.path(), "252:0");
std::fs::create_dir_all(dev.join("slaves")).unwrap();
assert_eq!(classify_sysfs_device(&dev), StorageClass::Unknown);
}
#[test]
fn slaves_aggregate_rotational() {
let dir = tempfile::tempdir().unwrap();
let dev = sysfs(dir.path(), "252:0");
mark_rotational(&add_slave(&dev, "sda"), "1");
assert_eq!(classify_sysfs_device(&dev), StorageClass::Hdd);
}
#[test]
fn slaves_aggregate_ssd() {
let dir = tempfile::tempdir().unwrap();
let dev = sysfs(dir.path(), "252:0");
mark_rotational(&add_slave(&dev, "nvme0n1"), "0");
assert_eq!(classify_sysfs_device(&dev), StorageClass::Ssd);
}
#[test]
fn nested_slaves_aggregate() {
let dir = tempfile::tempdir().unwrap();
let dev = sysfs(dir.path(), "252:1");
mark_rotational(&add_slave(&add_slave(&dev, "loop0"), "sdb"), "1");
assert_eq!(classify_sysfs_device(&dev), StorageClass::Hdd);
}
#[test]
fn mixed_slaves_prefer_hdd() {
let dir = tempfile::tempdir().unwrap();
let dev = sysfs(dir.path(), "9:0");
mark_rotational(&add_slave(&dev, "sdc"), "1");
mark_rotational(&add_slave(&dev, "nvme1n1"), "0");
assert_eq!(classify_sysfs_device(&dev), StorageClass::Hdd);
}
#[test]
fn dev_number_decode_matches_stat() {
use std::os::unix::fs::MetadataExt;
let meta = std::fs::metadata("/tmp").unwrap();
let dev = meta.dev();
let major = dev_major(dev);
let minor = dev_minor(dev);
let sys_dev = Path::new("/sys/dev/block").join(format!("{major}:{minor}"));
if sys_dev.exists() {
let class = classify_sysfs_device(&sys_dev);
assert!(matches!(
class,
StorageClass::Hdd | StorageClass::Ssd | StorageClass::Unknown
));
}
}
}
}