phoebus_os/installer-rs/crates/phoebus-executor/src/probe.rs

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);
}
}