//! 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 { 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::(), b.parse::()) { info.cores = b - a + 1; } } else if let Ok(n) = text.parse::() { 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::() { 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 { 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 { 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 { 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 { 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 { let mut sources: Vec = 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 = 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 { 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::().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 { 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 { 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); } }