phoebus_os/installer-rs/crates/phoebus-executor/src/probe.rs
Phoebus 3b219fc851
Some checks failed
ci / test (push) Has been cancelled
fix(agents): harden both user-level agent paths
2026-10-12 07:15:31 -07:00

633 lines
21 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 std::path::Path;
use phoebus_core::disk::{Disk, DiskKind};
use phoebus_core::hardware::{
CpuInfo, FirmwareMode, GpuInfo, GpuVendor, HardwareReport, NetworkDevice, VirtualMachine,
};
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
}
}
/// Extract `(vendor:device, pci_address)` from an `lspci -nn` line.
///
/// The numeric vendor:device pair is the last `[vvvv:dddd]` tag; the class
/// code (`[0300]`) has no colon and is ignored. The PCI address is the first
/// whitespace-delimited field (`01:00.0`).
fn parse_lspci_identity(line: &str) -> (Option<String>, Option<String>) {
let mut pair = None;
let bytes = line.as_bytes();
let mut i = 0;
while i < bytes.len() {
if bytes[i] == b'[' {
if let Some(rel) = line[i + 1..].find(']') {
let inner = &line[i + 1..i + 1 + rel];
if let Some((vendor, device)) = inner.split_once(':') {
let device = &device[..device.len().min(4)];
if vendor.len() == 4
&& device.len() == 4
&& vendor.chars().all(|c| c.is_ascii_hexdigit())
&& device.chars().all(|c| c.is_ascii_hexdigit())
{
pair = Some(format!(
"{}:{}",
vendor.to_ascii_lowercase(),
device.to_ascii_lowercase()
));
}
}
i += 1 + rel;
}
}
i += 1;
}
let address = line
.split_whitespace()
.next()
.filter(|t| t.contains(':') && t.contains('.'))
.map(str::to_string);
(pair, address)
}
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 virtual_machine = VirtualMachine::detect(
capture(runner, "systemd-detect-virt", &["--vm"]).trim(),
&read_trim("/sys/class/dmi/id/sys_vendor").unwrap_or_default(),
&read_trim("/sys/class/dmi/id/product_name").unwrap_or_default(),
);
let gpu_lines = lspci_filter(
runner,
"VGA compatible controller|3D controller|Display controller",
);
let gpus = gpu_lines
.iter()
.map(|l| {
let (pci_id, pci_address) = parse_lspci_identity(l);
GpuInfo {
vendor: classify_gpu(l),
description: l.clone(),
pci_id,
pci_address,
}
})
.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) = crate::command::capture_unleased(&mut std::process::Command::new("lsusb")) {
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()),
virtual_machine,
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,
}
}
/// Enumerate NVIDIA display controllers from sysfs.
///
/// `sysfs` is normally `/sys`; it is a parameter so the live driver decision
/// can be exercised against a fixture without root or the real machine's
/// hardware. Only display-class functions (`class >> 16 == 0x03`: VGA, 3D and
/// Display controllers) from vendor `0x10de` are returned.
pub fn probe_nvidia_display_devices(sysfs: &Path) -> Vec<GpuInfo> {
let mut out = Vec::new();
let dir = sysfs.join("bus/pci/devices");
let Ok(entries) = std::fs::read_dir(&dir) else {
return out;
};
for entry in entries.flatten() {
let base = entry.path();
let read = |name: &str| -> Option<String> {
std::fs::read_to_string(base.join(name))
.ok()
.map(|s| s.trim().to_string())
};
let (Some(class), Some(vendor), Some(device)) =
(read("class"), read("vendor"), read("device"))
else {
continue;
};
let parse = |s: &str| u32::from_str_radix(s.trim_start_matches("0x"), 16).ok();
let (Some(class), Some(vendor), Some(device)) =
(parse(&class), parse(&vendor), parse(&device))
else {
continue;
};
if (class >> 16) != 0x03 || vendor != 0x10de {
continue;
}
out.push(GpuInfo {
vendor: GpuVendor::Nvidia,
description: format!("NVIDIA display controller {vendor:04x}:{device:04x}"),
pci_id: Some(format!("{vendor:04x}:{device:04x}")),
pci_address: Some(entry.file_name().to_string_lossy().to_string()),
});
}
out.sort_by(|a, b| a.pci_id.cmp(&b.pci_id));
out
}
// ---------------------------------------------------------------------------
// 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",
// Debian live-boot mounts the medium here; the ISO/medium device must
// be identified so the installer can label and protect it.
"/run/live/medium",
"/run/live/rootfs",
"/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> {
// `-b` is required: without it lsblk prints human units ("30G") and the
// byte parse below silently yields 0, so every disk would report 0 B.
let out = capture(
runner,
"lsblk",
&["-bdn", "-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());
// Regression: the byte size must survive parsing (lsblk needs -b).
assert_eq!(vda.size_bytes, 32_212_254_720);
assert_eq!(vda.size_human(), "30.0 GiB");
}
#[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);
}
#[test]
fn lspci_identity_extracts_the_vendor_device_pair() {
let nvidia = "01:00.0 VGA compatible controller [0300]: NVIDIA Corporation GA104 [GeForce RTX 3070] [10de:2482] (rev a1)";
let (pair, address) = parse_lspci_identity(nvidia);
assert_eq!(pair.as_deref(), Some("10de:2482"));
assert_eq!(address.as_deref(), Some("01:00.0"));
assert_eq!(classify_gpu(nvidia), GpuVendor::Nvidia);
let intel = "00:02.0 VGA compatible controller [0300]: Intel Corporation Device [8086:9a60] (rev 01)";
assert_eq!(parse_lspci_identity(intel).0.as_deref(), Some("8086:9a60"));
// A line without a numeric pair must not fabricate one.
assert_eq!(
parse_lspci_identity("00:00.0 Host bridge: Intel"),
(None, Some("00:00.0".into()))
);
}
#[test]
fn sysfs_scan_finds_only_nvidia_display_controllers() {
let dir = tempfile::tempdir().unwrap();
let devices = dir.path().join("bus/pci/devices");
let write = |addr: &str, class: &str, vendor: &str, device: &str| {
let d = devices.join(addr);
std::fs::create_dir_all(&d).unwrap();
std::fs::write(d.join("class"), class).unwrap();
std::fs::write(d.join("vendor"), vendor).unwrap();
std::fs::write(d.join("device"), device).unwrap();
};
write("0000:01:00.0", "0x030000", "0x10de", "0x2482");
// NVIDIA's HDA audio function on the same card is not a display device.
write("0000:01:00.1", "0x040300", "0x10de", "0x228b");
// An Intel display controller is left to the in-tree driver.
write("0000:00:02.0", "0x030000", "0x8086", "0x9a60");
let found = probe_nvidia_display_devices(dir.path());
assert_eq!(found.len(), 1);
assert_eq!(found[0].pci_id.as_deref(), Some("10de:2482"));
assert_eq!(found[0].pci_address.as_deref(), Some("0000:01:00.0"));
}
}