488 lines
15 KiB
Rust
488 lines
15 KiB
Rust
//! Read-only hardware and disk probing.
|
|
//!
|
|
//! These functions never write. They take a `ProcessRunner` directly so they
|
|
//! still work in dry-run mode (mirroring the Bash prototype, where probing is
|
|
//! independent of `run_cmd`).
|
|
|
|
use std::collections::HashMap;
|
|
|
|
use phoebus_core::disk::{Disk, DiskKind};
|
|
use phoebus_core::hardware::{
|
|
CpuInfo, FirmwareMode, GpuInfo, GpuVendor, HardwareReport, NetworkDevice,
|
|
};
|
|
|
|
use crate::command::{CommandSpec, ProcessRunner};
|
|
|
|
fn capture(runner: &dyn ProcessRunner, program: &str, args: &[&str]) -> String {
|
|
let spec = CommandSpec::new("probe", program, program).args(args.iter().map(|s| s.to_string()));
|
|
match runner.execute(&spec) {
|
|
Ok(out) => out.stdout_lossy(),
|
|
Err(_) => String::new(),
|
|
}
|
|
}
|
|
|
|
fn read_trim(path: &str) -> Option<String> {
|
|
std::fs::read_to_string(path)
|
|
.ok()
|
|
.map(|s| s.trim().to_string())
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Hardware
|
|
// ---------------------------------------------------------------------------
|
|
|
|
pub fn probe_firmware() -> FirmwareMode {
|
|
if std::path::Path::new("/sys/firmware/efi").is_dir() {
|
|
FirmwareMode::Uefi
|
|
} else {
|
|
FirmwareMode::Bios
|
|
}
|
|
}
|
|
|
|
pub fn probe_cpu() -> CpuInfo {
|
|
let mut info = CpuInfo::default();
|
|
if let Ok(text) = std::fs::read_to_string("/proc/cpuinfo") {
|
|
let mut threads = 0u32;
|
|
for line in text.lines() {
|
|
if line.starts_with("processor") {
|
|
threads += 1;
|
|
}
|
|
if let Some((key, value)) = line.split_once(':') {
|
|
let key = key.trim();
|
|
let value = value.trim();
|
|
match key {
|
|
"vendor_id" if info.vendor.is_empty() => info.vendor = value.into(),
|
|
"model name" if info.model.is_empty() => info.model = value.into(),
|
|
"flags" if info.features.is_empty() => {
|
|
info.features = value.split_whitespace().map(str::to_string).collect();
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
info.threads = threads;
|
|
}
|
|
if let Ok(text) = std::fs::read_to_string("/sys/devices/system/cpu/online") {
|
|
// "0-7" or "0"
|
|
let text = text.trim();
|
|
if let Some((a, b)) = text.split_once('-') {
|
|
if let (Ok(a), Ok(b)) = (a.parse::<u32>(), b.parse::<u32>()) {
|
|
info.cores = b - a + 1;
|
|
}
|
|
} else if let Ok(n) = text.parse::<u32>() {
|
|
info.cores = n + 1;
|
|
}
|
|
}
|
|
if info.cores == 0 {
|
|
info.cores = info.threads.max(1);
|
|
}
|
|
info
|
|
}
|
|
|
|
pub fn probe_memory_mib() -> u64 {
|
|
if let Ok(text) = std::fs::read_to_string("/proc/meminfo") {
|
|
for line in text.lines() {
|
|
if let Some(rest) = line.strip_prefix("MemTotal:") {
|
|
if let Some(kb) = rest.split_whitespace().next() {
|
|
if let Ok(kb) = kb.parse::<u64>() {
|
|
return kb / 1024;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
0
|
|
}
|
|
|
|
fn classify_gpu(line: &str) -> GpuVendor {
|
|
let lower = line.to_ascii_lowercase();
|
|
if lower.contains("nvidia") {
|
|
GpuVendor::Nvidia
|
|
} else if lower.contains("amd") || lower.contains("ati") || lower.contains("advanced micro") {
|
|
GpuVendor::Amd
|
|
} else if lower.contains("intel") {
|
|
GpuVendor::Intel
|
|
} else {
|
|
GpuVendor::Unknown
|
|
}
|
|
}
|
|
|
|
fn lspci_filter(runner: &dyn ProcessRunner, pattern: &str) -> Vec<String> {
|
|
let out = capture(runner, "lspci", &["-nn"]);
|
|
out.lines()
|
|
.filter(|l| {
|
|
let l = l.to_ascii_lowercase();
|
|
pattern
|
|
.split('|')
|
|
.any(|p| l.contains(&p.to_ascii_lowercase()))
|
|
})
|
|
.map(str::to_string)
|
|
.collect()
|
|
}
|
|
|
|
pub fn probe_hardware(runner: &dyn ProcessRunner) -> HardwareReport {
|
|
let cpu = probe_cpu();
|
|
let gpu_lines = lspci_filter(
|
|
runner,
|
|
"VGA compatible controller|3D controller|Display controller",
|
|
);
|
|
let gpus = gpu_lines
|
|
.iter()
|
|
.map(|l| GpuInfo {
|
|
vendor: classify_gpu(l),
|
|
description: l.clone(),
|
|
})
|
|
.collect();
|
|
|
|
let mut network = Vec::new();
|
|
if let Ok(entries) = std::fs::read_dir("/sys/class/net") {
|
|
for entry in entries.flatten() {
|
|
let name = entry.file_name().to_string_lossy().to_string();
|
|
if name == "lo" {
|
|
continue;
|
|
}
|
|
let base = entry.path();
|
|
let wireless = base.join("wireless").exists() || base.join("phy80211").exists();
|
|
let operstate =
|
|
read_trim(&base.join("operstate").to_string_lossy()).unwrap_or_default();
|
|
network.push(NetworkDevice {
|
|
name,
|
|
wireless,
|
|
operstate,
|
|
});
|
|
}
|
|
}
|
|
|
|
let mut bluetooth = lspci_filter(runner, "Bluetooth");
|
|
if let Ok(out) = std::process::Command::new("lsusb").output() {
|
|
let text = String::from_utf8_lossy(&out.stdout);
|
|
for line in text
|
|
.lines()
|
|
.filter(|l| l.to_ascii_lowercase().contains("bluetooth"))
|
|
{
|
|
bluetooth.push(line.to_string());
|
|
}
|
|
}
|
|
|
|
let input_devices = std::fs::read_to_string("/proc/bus/input/devices")
|
|
.map(|t| t.lines().filter(|l| l.starts_with("N: Name=")).count() as u32)
|
|
.unwrap_or(0);
|
|
|
|
let laptop = std::fs::read_dir("/sys/class/power_supply")
|
|
.map(|entries| {
|
|
entries
|
|
.flatten()
|
|
.any(|e| e.file_name().to_string_lossy().starts_with("BAT"))
|
|
})
|
|
.unwrap_or(false);
|
|
|
|
HardwareReport {
|
|
firmware: Some(probe_firmware()),
|
|
cpu,
|
|
memory_mib: probe_memory_mib(),
|
|
gpus,
|
|
network,
|
|
storage_controllers: lspci_filter(runner, "SATA controller|NVMe|RAID bus controller"),
|
|
audio: lspci_filter(runner, "Audio device"),
|
|
bluetooth,
|
|
usb_controllers: lspci_filter(runner, "USB controller"),
|
|
input_devices,
|
|
laptop,
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Disks
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Parse `lsblk -P` output (`KEY="value" ...`) into a map.
|
|
pub fn parse_pairs(line: &str) -> HashMap<String, String> {
|
|
let mut map = HashMap::new();
|
|
let bytes = line.as_bytes();
|
|
let mut i = 0;
|
|
while i < bytes.len() {
|
|
// skip whitespace
|
|
while i < bytes.len() && bytes[i].is_ascii_whitespace() {
|
|
i += 1;
|
|
}
|
|
let key_start = i;
|
|
while i < bytes.len() && bytes[i] != b'=' {
|
|
i += 1;
|
|
}
|
|
if i >= bytes.len() {
|
|
break;
|
|
}
|
|
let key = line[key_start..i].to_string();
|
|
i += 1; // skip '='
|
|
if i >= bytes.len() || bytes[i] != b'"' {
|
|
continue;
|
|
}
|
|
i += 1;
|
|
let mut value = String::new();
|
|
while i < bytes.len() {
|
|
match bytes[i] {
|
|
b'\\' if i + 1 < bytes.len() => {
|
|
value.push(bytes[i + 1] as char);
|
|
i += 2;
|
|
}
|
|
b'"' => {
|
|
i += 1;
|
|
break;
|
|
}
|
|
c => {
|
|
value.push(c as char);
|
|
i += 1;
|
|
}
|
|
}
|
|
}
|
|
map.insert(key, value);
|
|
}
|
|
map
|
|
}
|
|
|
|
fn read_mounts() -> Vec<(String, String)> {
|
|
let mut out = Vec::new();
|
|
if let Ok(text) = std::fs::read_to_string("/proc/mounts") {
|
|
for line in text.lines() {
|
|
let mut parts = line.split_whitespace();
|
|
if let (Some(src), Some(mp)) = (parts.next(), parts.next()) {
|
|
out.push((src.to_string(), mp.to_string()));
|
|
}
|
|
}
|
|
}
|
|
out
|
|
}
|
|
|
|
fn read_cmdline() -> Vec<String> {
|
|
std::fs::read_to_string("/proc/cmdline")
|
|
.map(|t| t.split_whitespace().map(str::to_string).collect())
|
|
.unwrap_or_default()
|
|
}
|
|
|
|
fn is_block_device(path: &str) -> bool {
|
|
use std::os::unix::fs::FileTypeExt;
|
|
std::fs::metadata(path)
|
|
.map(|m| m.file_type().is_block_device())
|
|
.unwrap_or(false)
|
|
}
|
|
|
|
fn disk_kind(name: &str, path: &str) -> DiskKind {
|
|
if name.starts_with("sr") || path.starts_with("/dev/sr") {
|
|
DiskKind::Optical
|
|
} else if name.starts_with("loop") || path.starts_with("/dev/loop") {
|
|
DiskKind::Loop
|
|
} else if name.starts_with("dm-") || path.starts_with("/dev/mapper") {
|
|
DiskKind::DeviceMapper
|
|
} else {
|
|
DiskKind::Physical
|
|
}
|
|
}
|
|
|
|
/// List child partition device paths for a disk.
|
|
pub fn disk_partitions(runner: &dyn ProcessRunner, disk: &str) -> Vec<String> {
|
|
let out = capture(runner, "lsblk", &["-rno", "NAME", disk]);
|
|
out.lines()
|
|
.skip(1)
|
|
.map(|l| l.trim())
|
|
.filter(|l| !l.is_empty())
|
|
.map(|name| format!("/dev/{name}"))
|
|
.collect()
|
|
}
|
|
|
|
fn parent_disk(runner: &dyn ProcessRunner, dev: &str) -> String {
|
|
if dev.starts_with("/dev/loop")
|
|
|| dev.starts_with("/dev/dm-")
|
|
|| dev.starts_with("/dev/mapper")
|
|
|| dev.starts_with("/dev/sr")
|
|
{
|
|
return dev.to_string();
|
|
}
|
|
let out = capture(runner, "lsblk", &["-no", "PKNAME", dev]);
|
|
match out.lines().next().map(str::trim).filter(|s| !s.is_empty()) {
|
|
Some(pk) => format!("/dev/{pk}"),
|
|
None => dev.to_string(),
|
|
}
|
|
}
|
|
|
|
fn live_source_disks(runner: &dyn ProcessRunner) -> Vec<String> {
|
|
let mut sources: Vec<String> = Vec::new();
|
|
for tok in read_cmdline() {
|
|
if let Some((key, value)) = tok.split_once('=') {
|
|
if matches!(key, "root" | "cdroot" | "boot") {
|
|
sources.push(value.to_string());
|
|
}
|
|
}
|
|
}
|
|
let mounts = read_mounts();
|
|
for mp in [
|
|
"/",
|
|
"/run/initramfs",
|
|
"/run/live",
|
|
"/mnt/cdrom",
|
|
"/mnt/live",
|
|
"/lib/live",
|
|
] {
|
|
if let Some((src, _)) = mounts.iter().find(|(_, m)| m == mp) {
|
|
sources.push(src.clone());
|
|
}
|
|
}
|
|
let mut disks: Vec<String> = Vec::new();
|
|
for src in sources {
|
|
if !src.starts_with("/dev/") {
|
|
continue;
|
|
}
|
|
if !is_block_device(&src) {
|
|
continue;
|
|
}
|
|
let disk = parent_disk(runner, &src);
|
|
if !disks.contains(&disk) {
|
|
disks.push(disk);
|
|
}
|
|
}
|
|
disks
|
|
}
|
|
|
|
pub fn probe_disks(runner: &dyn ProcessRunner) -> Vec<Disk> {
|
|
let out = capture(
|
|
runner,
|
|
"lsblk",
|
|
&["-dn", "-P", "-o", "NAME,MODEL,SIZE,TRAN,RM,RO"],
|
|
);
|
|
let mounts = read_mounts();
|
|
let live = live_source_disks(runner);
|
|
|
|
let mut disks = Vec::new();
|
|
for line in out.lines() {
|
|
let pairs = parse_pairs(line);
|
|
let Some(name) = pairs.get("NAME") else {
|
|
continue;
|
|
};
|
|
let path = format!("/dev/{name}");
|
|
let kind = disk_kind(name, &path);
|
|
let size = pairs
|
|
.get("SIZE")
|
|
.and_then(|s| s.parse::<u64>().ok())
|
|
.unwrap_or(0);
|
|
let read_only = pairs.get("RO").map(|v| v == "1").unwrap_or(false);
|
|
let removable = pairs.get("RM").map(|v| v == "1").unwrap_or(false);
|
|
let model = pairs
|
|
.get("MODEL")
|
|
.map(|s| s.trim().to_string())
|
|
.filter(|s| !s.is_empty());
|
|
let transport = pairs
|
|
.get("TRAN")
|
|
.map(|s| s.trim().to_string())
|
|
.filter(|s| !s.is_empty());
|
|
|
|
// Mounted when the disk or any child partition is a mount source.
|
|
let mounted = mounts
|
|
.iter()
|
|
.any(|(src, _)| src == &path || is_partition_of(&path, src));
|
|
|
|
let live_media = live.iter().any(|d| d == &path);
|
|
disks.push(Disk {
|
|
path,
|
|
model,
|
|
size_bytes: size,
|
|
transport,
|
|
removable,
|
|
read_only,
|
|
mounted,
|
|
// lsblk only lists kernel block devices, so entries are block
|
|
// devices by construction. The explicit check remains available to
|
|
// callers that build a `Disk` from other sources.
|
|
is_block_device: true,
|
|
kind,
|
|
live_media,
|
|
});
|
|
}
|
|
disks.sort_by(|a, b| a.path.cmp(&b.path));
|
|
disks
|
|
}
|
|
|
|
pub fn probe_disk_layout(runner: &dyn ProcessRunner, disk: &str) -> String {
|
|
capture(
|
|
runner,
|
|
"lsblk",
|
|
&["-o", "NAME,SIZE,TYPE,FSTYPE,LABEL,MOUNTPOINTS", disk],
|
|
)
|
|
}
|
|
|
|
/// True when `device` is a partition of `disk` (vda -> vda1, nvme0n1 -> nvme0n1p1).
|
|
pub fn is_partition_of(disk: &str, device: &str) -> bool {
|
|
let Some(rest) = device.strip_prefix(disk) else {
|
|
return false;
|
|
};
|
|
if rest.is_empty() {
|
|
return false;
|
|
}
|
|
if rest.chars().all(|c| c.is_ascii_digit()) {
|
|
return true;
|
|
}
|
|
if let Some(digits) = rest.strip_prefix('p') {
|
|
return !digits.is_empty() && digits.chars().all(|c| c.is_ascii_digit());
|
|
}
|
|
false
|
|
}
|
|
|
|
pub fn blkid_uuid(runner: &dyn ProcessRunner, device: &str) -> Option<String> {
|
|
let out = capture(runner, "blkid", &["-s", "UUID", "-o", "value", device]);
|
|
out.lines()
|
|
.next()
|
|
.map(str::trim)
|
|
.filter(|s| !s.is_empty())
|
|
.map(str::to_string)
|
|
}
|
|
|
|
pub fn blkid_partlabel(runner: &dyn ProcessRunner, device: &str) -> Option<String> {
|
|
let out = capture(runner, "blkid", &["-s", "PARTLABEL", "-o", "value", device]);
|
|
out.lines()
|
|
.next()
|
|
.map(str::trim)
|
|
.filter(|s| !s.is_empty())
|
|
.map(str::to_string)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::command::{CommandOutput, RecordingRunner};
|
|
|
|
#[test]
|
|
fn parse_pairs_handles_quotes_and_escapes() {
|
|
let line =
|
|
r#"NAME="vda" MODEL="QEMU HARDDISK" SIZE="32212254720" TRAN="virtio" RM="0" RO="0""#;
|
|
let pairs = parse_pairs(line);
|
|
assert_eq!(pairs.get("NAME").unwrap(), "vda");
|
|
assert_eq!(pairs.get("SIZE").unwrap(), "32212254720");
|
|
assert_eq!(pairs.get("MODEL").unwrap(), "QEMU HARDDISK");
|
|
}
|
|
|
|
#[test]
|
|
fn probe_disks_classifies_optical_as_protected() {
|
|
let runner = RecordingRunner::new();
|
|
runner.set_response(
|
|
"lsblk",
|
|
CommandOutput {
|
|
status: 0,
|
|
success: true,
|
|
stdout: b"NAME=\"sr0\" MODEL=\"QEMU DVD-ROM\" SIZE=\"1073741824\" TRAN=\"sata\" RM=\"1\" RO=\"1\"\nNAME=\"vda\" MODEL=\"QEMU HARDDISK\" SIZE=\"32212254720\" TRAN=\"virtio\" RM=\"0\" RO=\"0\"\n".to_vec(),
|
|
stderr: Vec::new(),
|
|
duration: std::time::Duration::from_millis(1),
|
|
},
|
|
);
|
|
let disks = probe_disks(&runner);
|
|
let sr = disks.iter().find(|d| d.path == "/dev/sr0").unwrap();
|
|
assert!(sr.is_protected());
|
|
let vda = disks.iter().find(|d| d.path == "/dev/vda").unwrap();
|
|
assert!(!vda.is_protected());
|
|
}
|
|
|
|
#[test]
|
|
fn disk_kind_classification() {
|
|
assert_eq!(disk_kind("sr0", "/dev/sr0"), DiskKind::Optical);
|
|
assert_eq!(disk_kind("loop0", "/dev/loop0"), DiskKind::Loop);
|
|
assert_eq!(disk_kind("dm-0", "/dev/dm-0"), DiskKind::DeviceMapper);
|
|
assert_eq!(disk_kind("vda", "/dev/vda"), DiskKind::Physical);
|
|
}
|
|
}
|