fixed hardware_db and improved stability and robustness of generic sal
This commit is contained in:
@@ -91,24 +91,30 @@ impl OptimizerEngine {
|
||||
// 1. Efficiency Metric (Throughput per Watt)
|
||||
// If throughput is 0 (unsupported), fallback to Frequency per Watt
|
||||
let efficiency_curr = if curr.throughput > 0.0 {
|
||||
curr.throughput as f32 / curr.power_w.max(0.1)
|
||||
curr.throughput as f32 / curr.power_w.max(1.0)
|
||||
} else {
|
||||
curr.freq_mhz / curr.power_w.max(0.1)
|
||||
curr.freq_mhz / curr.power_w.max(1.0)
|
||||
};
|
||||
|
||||
let efficiency_next = if next.throughput > 0.0 {
|
||||
next.throughput as f32 / next.power_w.max(0.1)
|
||||
next.throughput as f32 / next.power_w.max(1.0)
|
||||
} else {
|
||||
next.freq_mhz / next.power_w.max(0.1)
|
||||
next.freq_mhz / next.power_w.max(1.0)
|
||||
};
|
||||
|
||||
// Diminishing returns: how much efficiency drops per additional watt
|
||||
let efficiency_drop = (efficiency_curr - efficiency_next) / (next.power_w - curr.power_w).max(0.1);
|
||||
let p_delta = (next.power_w - curr.power_w).max(0.5);
|
||||
let efficiency_drop = (efficiency_curr - efficiency_next) / p_delta;
|
||||
|
||||
// 2. Thermal Acceleration (d2T/dW2)
|
||||
let dt_dw_prev = (curr.temp_c - prev.temp_c) / (curr.power_w - prev.power_w).max(0.1);
|
||||
let dt_dw_next = (next.temp_c - curr.temp_c) / (next.power_w - curr.power_w).max(0.1);
|
||||
let temp_accel = (dt_dw_next - dt_dw_prev) / (next.power_w - prev.power_w).max(0.1);
|
||||
let p_delta_prev = (curr.power_w - prev.power_w).max(0.5);
|
||||
let p_delta_next = (next.power_w - curr.power_w).max(0.5);
|
||||
|
||||
let dt_dw_prev = (curr.temp_c - prev.temp_c) / p_delta_prev;
|
||||
let dt_dw_next = (next.temp_c - curr.temp_c) / p_delta_next;
|
||||
|
||||
let p_total_delta = (next.power_w - prev.power_w).max(1.0);
|
||||
let temp_accel = (dt_dw_next - dt_dw_prev) / p_total_delta;
|
||||
|
||||
// 3. Wall Detection (Any drop in absolute frequency/throughput is a hard wall)
|
||||
let is_throttling = next.freq_mhz < curr.freq_mhz || (next.throughput > 0.0 && next.throughput < curr.throughput);
|
||||
|
||||
@@ -1,16 +1,16 @@
|
||||
use anyhow::Result;
|
||||
use std::process::Child;
|
||||
use std::time::{Duration, Instant};
|
||||
use std::thread;
|
||||
|
||||
pub trait Workload {
|
||||
/// Starts the workload with specified threads and load percentage.
|
||||
pub trait Workload: Send + Sync {
|
||||
fn start(&mut self, threads: usize, load_percent: usize) -> Result<()>;
|
||||
/// Stops the workload.
|
||||
fn stop(&mut self) -> Result<()>;
|
||||
/// Returns the current throughput (e.g., ops/sec).
|
||||
fn get_throughput(&self) -> Result<f64>;
|
||||
}
|
||||
|
||||
pub struct StressNg {
|
||||
child: Option<std::process::Child>,
|
||||
child: Option<Child>,
|
||||
}
|
||||
|
||||
impl StressNg {
|
||||
@@ -21,7 +21,7 @@ impl StressNg {
|
||||
|
||||
impl Workload for StressNg {
|
||||
fn start(&mut self, threads: usize, load_percent: usize) -> Result<()> {
|
||||
self.stop()?; // Ensure any previous instance is stopped
|
||||
self.stop()?;
|
||||
|
||||
let child = std::process::Command::new("stress-ng")
|
||||
.args([
|
||||
@@ -37,15 +37,32 @@ impl Workload for StressNg {
|
||||
|
||||
fn stop(&mut self) -> Result<()> {
|
||||
if let Some(mut child) = self.child.take() {
|
||||
let _ = child.kill();
|
||||
let _ = child.wait();
|
||||
// Try SIGTERM first
|
||||
#[cfg(unix)]
|
||||
{
|
||||
use libc::{kill, SIGTERM};
|
||||
unsafe { kill(child.id() as i32, SIGTERM); }
|
||||
}
|
||||
|
||||
let start = Instant::now();
|
||||
let mut exited = false;
|
||||
while start.elapsed() < Duration::from_secs(2) {
|
||||
if let Ok(Some(_)) = child.try_wait() {
|
||||
exited = true;
|
||||
break;
|
||||
}
|
||||
thread::sleep(Duration::from_millis(100));
|
||||
}
|
||||
|
||||
if !exited {
|
||||
let _ = child.kill();
|
||||
let _ = child.wait();
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn get_throughput(&self) -> Result<f64> {
|
||||
// In a real implementation, we would parse stress-ng's temporary results
|
||||
// or use a different workload that provides live throughput.
|
||||
Ok(0.0)
|
||||
}
|
||||
}
|
||||
|
||||
64
src/main.rs
64
src/main.rs
@@ -6,7 +6,7 @@ mod ui;
|
||||
mod engine;
|
||||
mod cli;
|
||||
|
||||
use miette::{Result, IntoDiagnostic, Diagnostic, Report};
|
||||
use miette::{Result, IntoDiagnostic, Diagnostic, Report, Context};
|
||||
use thiserror::Error;
|
||||
use std::sync::mpsc;
|
||||
use std::thread;
|
||||
@@ -30,7 +30,7 @@ use mediator::{TelemetryState, UiCommand, BenchmarkPhase};
|
||||
use sal::traits::{AuditError, PlatformSal};
|
||||
use sal::mock::MockSal;
|
||||
use sal::heuristic::engine::HeuristicEngine;
|
||||
use load::StressNg;
|
||||
use load::{StressNg, Workload};
|
||||
use orchestrator::BenchmarkOrchestrator;
|
||||
use ui::dashboard::{draw_dashboard, DashboardState};
|
||||
use engine::OptimizationResult;
|
||||
@@ -108,10 +108,10 @@ fn main() -> Result<()> {
|
||||
info!("ember-tune starting with args: {:?}", args);
|
||||
|
||||
// 2. Platform Detection & Audit
|
||||
let sal: Box<dyn PlatformSal> = if args.mock {
|
||||
Box::new(MockSal::new())
|
||||
let sal: Arc<dyn PlatformSal> = if args.mock {
|
||||
Arc::new(MockSal::new())
|
||||
} else {
|
||||
HeuristicEngine::detect_and_build()?
|
||||
HeuristicEngine::detect_and_build()?.into()
|
||||
};
|
||||
|
||||
println!("{}", console::style("─── Pre-flight System Audit ───").bold().cyan());
|
||||
@@ -122,9 +122,7 @@ fn main() -> Result<()> {
|
||||
io::Write::flush(&mut io::stdout()).into_diagnostic()?;
|
||||
|
||||
match step.outcome {
|
||||
Ok(_) => {
|
||||
println!("{}", console::style("[✓]").green());
|
||||
}
|
||||
Ok(_) => { println!("{}", console::style("[✓]").green()); }
|
||||
Err(e) => {
|
||||
println!("{}", console::style("[✗]").red());
|
||||
audit_failures.push(e);
|
||||
@@ -137,10 +135,8 @@ fn main() -> Result<()> {
|
||||
return Err(Report::new(MultiAuditError { errors: audit_failures }));
|
||||
}
|
||||
|
||||
println!("{}", console::style("✓ All pre-flight audits passed.").green().bold());
|
||||
thread::sleep(Duration::from_secs(1));
|
||||
|
||||
if args.audit_only {
|
||||
println!("{}", console::style("✓ All pre-flight audits passed.").green().bold());
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -159,21 +155,22 @@ fn main() -> Result<()> {
|
||||
let (telemetry_tx, telemetry_rx) = mpsc::channel::<TelemetryState>();
|
||||
let (command_tx, command_rx) = mpsc::channel::<UiCommand>();
|
||||
|
||||
let c_tx = command_tx.clone();
|
||||
ctrlc::set_handler(move || {
|
||||
let _ = c_tx.send(UiCommand::Abort);
|
||||
r.store(false, Ordering::SeqCst);
|
||||
}).expect("Error setting Ctrl-C handler");
|
||||
|
||||
// 5. Spawn Backend Orchestrator
|
||||
let sal_backend = sal.clone();
|
||||
let backend_handle = thread::spawn(move || {
|
||||
let workload = Box::new(StressNg::new());
|
||||
|
||||
let mut orchestrator = BenchmarkOrchestrator::new(
|
||||
sal,
|
||||
sal_backend,
|
||||
workload,
|
||||
telemetry_tx,
|
||||
command_rx,
|
||||
);
|
||||
|
||||
orchestrator.run()
|
||||
});
|
||||
|
||||
@@ -197,6 +194,8 @@ fn main() -> Result<()> {
|
||||
history_mhz: Vec::new(),
|
||||
log_event: None,
|
||||
metadata: std::collections::HashMap::new(),
|
||||
is_emergency: false,
|
||||
emergency_reason: None,
|
||||
};
|
||||
|
||||
let tick_rate = Duration::from_millis(100);
|
||||
@@ -233,29 +232,38 @@ fn main() -> Result<()> {
|
||||
}
|
||||
}
|
||||
|
||||
if last_tick.elapsed() >= tick_rate {
|
||||
last_tick = Instant::now();
|
||||
}
|
||||
|
||||
if backend_handle.is_finished() {
|
||||
thread::sleep(Duration::from_secs(1));
|
||||
break;
|
||||
}
|
||||
if last_tick.elapsed() >= tick_rate { last_tick = Instant::now(); }
|
||||
if backend_handle.is_finished() { break; }
|
||||
}
|
||||
|
||||
// 7. Terminal Restoration
|
||||
disable_raw_mode().into_diagnostic()?;
|
||||
execute!(terminal.backend_mut(), LeaveAlternateScreen).into_diagnostic()?;
|
||||
terminal.show_cursor().into_diagnostic()?;
|
||||
let _ = disable_raw_mode();
|
||||
let _ = execute!(terminal.backend_mut(), LeaveAlternateScreen);
|
||||
let _ = terminal.show_cursor();
|
||||
|
||||
// 8. Final Report (Post-TUI)
|
||||
match backend_handle.join() {
|
||||
// 8. Final Report & Hardware Restoration
|
||||
let join_res = backend_handle.join();
|
||||
|
||||
// Explicit hardware restoration
|
||||
info!("Restoring hardware state...");
|
||||
if let Err(e) = sal.restore() {
|
||||
error!("Failed to restore hardware state: {}", e);
|
||||
}
|
||||
|
||||
match join_res {
|
||||
Ok(Ok(result)) => {
|
||||
print_summary_report(&result);
|
||||
}
|
||||
Ok(Err(e)) => {
|
||||
if e.to_string() == "ABORTED" {
|
||||
let err_str = e.to_string();
|
||||
if err_str == "ABORTED" {
|
||||
println!("{}", "Benchmark aborted by user.".yellow());
|
||||
} else if err_str.contains("EMERGENCY_ABORT") {
|
||||
println!();
|
||||
println!("{}", " 🚨 EMERGENCY ABORT TRIGGERED ".bold().on_red().white());
|
||||
println!("Reason: {}", err_str.replace("EMERGENCY_ABORT: ", "").red().bold());
|
||||
println!("{}", "Hardware state has been restored to safe defaults.".yellow());
|
||||
println!();
|
||||
} else {
|
||||
error!("Orchestrator encountered error: {}", e);
|
||||
eprintln!("{} {}", "Error:".red().bold(), e);
|
||||
|
||||
@@ -42,6 +42,8 @@ pub struct TelemetryState {
|
||||
|
||||
pub log_event: Option<String>,
|
||||
pub metadata: std::collections::HashMap<String, String>,
|
||||
pub is_emergency: bool,
|
||||
pub emergency_reason: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
|
||||
@@ -4,14 +4,17 @@ use std::time::{Duration, Instant};
|
||||
use std::thread;
|
||||
use std::collections::VecDeque;
|
||||
use sysinfo::System;
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::Mutex;
|
||||
|
||||
use crate::sal::traits::{PlatformSal};
|
||||
use crate::sal::traits::{PlatformSal, AuditStep, SafetyStatus};
|
||||
use crate::load::Workload;
|
||||
use crate::mediator::{TelemetryState, UiCommand, BenchmarkPhase};
|
||||
use crate::engine::{OptimizerEngine, ThermalProfile, ThermalPoint, OptimizationResult};
|
||||
|
||||
pub struct BenchmarkOrchestrator {
|
||||
sal: Box<dyn PlatformSal>,
|
||||
sal: Arc<dyn PlatformSal>,
|
||||
workload: Box<dyn Workload>,
|
||||
telemetry_tx: mpsc::Sender<TelemetryState>,
|
||||
command_rx: mpsc::Receiver<UiCommand>,
|
||||
@@ -27,11 +30,15 @@ pub struct BenchmarkOrchestrator {
|
||||
// --- Static Info ---
|
||||
cpu_model: String,
|
||||
total_ram_gb: u64,
|
||||
|
||||
// --- Safety ---
|
||||
emergency_abort: Arc<AtomicBool>,
|
||||
emergency_reason: Arc<Mutex<Option<String>>>,
|
||||
}
|
||||
|
||||
impl BenchmarkOrchestrator {
|
||||
pub fn new(
|
||||
sal: Box<dyn PlatformSal>,
|
||||
sal: Arc<dyn PlatformSal>,
|
||||
workload: Box<dyn Workload>,
|
||||
telemetry_tx: mpsc::Sender<TelemetryState>,
|
||||
command_rx: mpsc::Receiver<UiCommand>,
|
||||
@@ -57,12 +64,17 @@ impl BenchmarkOrchestrator {
|
||||
history_mhz: VecDeque::with_capacity(120),
|
||||
cpu_model,
|
||||
total_ram_gb,
|
||||
emergency_abort: Arc::new(AtomicBool::new(false)),
|
||||
emergency_reason: Arc::new(Mutex::new(None)),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn run(&mut self) -> Result<OptimizationResult> {
|
||||
self.log("Starting ember-tune Benchmark Sequence.")?;
|
||||
|
||||
// Start Watchdog Monitor
|
||||
let _watchdog_handle = self.spawn_watchdog_monitor();
|
||||
|
||||
// Phase 1: Audit & Baseline
|
||||
self.phase = BenchmarkPhase::Auditing;
|
||||
for step in self.sal.audit() {
|
||||
@@ -111,11 +123,6 @@ impl BenchmarkOrchestrator {
|
||||
|
||||
while step_start.elapsed() < Duration::from_secs(45) {
|
||||
self.check_abort()?;
|
||||
if self.sal.check_emergency()? {
|
||||
self.log("⚠ EMERGENCY ABORT: Watchdog triggered!")?;
|
||||
self.workload.stop()?;
|
||||
return Err(anyhow::anyhow!("Hardware Watchdog Triggered"));
|
||||
}
|
||||
|
||||
let t = self.sal.get_temp().unwrap_or(0.0);
|
||||
step_temps.push_back(t);
|
||||
@@ -204,6 +211,35 @@ impl BenchmarkOrchestrator {
|
||||
Ok(res)
|
||||
}
|
||||
|
||||
fn spawn_watchdog_monitor(&self) -> thread::JoinHandle<()> {
|
||||
let abort = self.emergency_abort.clone();
|
||||
let reason_store = self.emergency_reason.clone();
|
||||
let sal = self.sal.clone();
|
||||
|
||||
thread::spawn(move || {
|
||||
while !abort.load(Ordering::SeqCst) {
|
||||
let status = sal.get_safety_status();
|
||||
match status {
|
||||
Ok(SafetyStatus::EmergencyAbort(reason)) => {
|
||||
*reason_store.lock().unwrap() = Some(reason.clone());
|
||||
abort.store(true, Ordering::SeqCst);
|
||||
break;
|
||||
}
|
||||
Ok(SafetyStatus::Warning(_msg)) | Ok(SafetyStatus::Critical(_msg)) => {
|
||||
// Send warning log to UI
|
||||
}
|
||||
Ok(SafetyStatus::Nominal) => {}
|
||||
Err(e) => {
|
||||
*reason_store.lock().unwrap() = Some(format!("Watchdog Sensor Failure: {}", e));
|
||||
abort.store(true, Ordering::SeqCst);
|
||||
break;
|
||||
}
|
||||
}
|
||||
thread::sleep(Duration::from_millis(100));
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
pub fn generate_result(&self, is_partial: bool) -> OptimizationResult {
|
||||
let r_theta = self.engine.calculate_thermal_resistance(&self.profile);
|
||||
let knee = self.engine.find_silicon_knee(&self.profile);
|
||||
@@ -221,6 +257,11 @@ impl BenchmarkOrchestrator {
|
||||
}
|
||||
|
||||
fn check_abort(&self) -> Result<()> {
|
||||
if self.emergency_abort.load(Ordering::SeqCst) {
|
||||
let reason = self.emergency_reason.lock().unwrap().clone().unwrap_or_else(|| "Unknown safety trigger".to_string());
|
||||
return Err(anyhow::anyhow!("EMERGENCY_ABORT: {}", reason));
|
||||
}
|
||||
|
||||
if let Ok(cmd) = self.command_rx.try_recv() {
|
||||
match cmd {
|
||||
UiCommand::Abort => {
|
||||
@@ -250,6 +291,8 @@ impl BenchmarkOrchestrator {
|
||||
history_mhz: Vec::new(),
|
||||
log_event: Some(msg.to_string()),
|
||||
metadata: std::collections::HashMap::new(),
|
||||
is_emergency: self.emergency_abort.load(Ordering::SeqCst),
|
||||
emergency_reason: self.emergency_reason.lock().unwrap().clone(),
|
||||
};
|
||||
self.telemetry_tx.send(state).map_err(|_| anyhow::anyhow!("Telemetry channel closed"))
|
||||
}
|
||||
@@ -287,6 +330,8 @@ impl BenchmarkOrchestrator {
|
||||
history_mhz: self.history_mhz.iter().cloned().collect(),
|
||||
log_event: None,
|
||||
metadata: std::collections::HashMap::new(),
|
||||
is_emergency: self.emergency_abort.load(Ordering::SeqCst),
|
||||
emergency_reason: self.emergency_reason.lock().unwrap().clone(),
|
||||
};
|
||||
self.telemetry_tx.send(state).map_err(|_| anyhow::anyhow!("Telemetry channel closed"))
|
||||
}
|
||||
|
||||
@@ -1,11 +1,11 @@
|
||||
use super::traits::{PreflightAuditor, EnvironmentGuard, SensorBus, ActuatorBus, HardwareWatchdog, AuditError, AuditStep};
|
||||
use super::traits::{PreflightAuditor, EnvironmentGuard, SensorBus, ActuatorBus, HardwareWatchdog, AuditError, AuditStep, SafetyStatus};
|
||||
use anyhow::{Result, Context};
|
||||
use std::fs;
|
||||
use std::path::PathBuf;
|
||||
use std::process::Command;
|
||||
use std::time::{Duration, Instant};
|
||||
use std::sync::Mutex;
|
||||
use tracing::debug;
|
||||
use tracing::{debug, warn};
|
||||
|
||||
pub struct DellXps9380Sal {
|
||||
temp_path: PathBuf,
|
||||
@@ -18,6 +18,8 @@ pub struct DellXps9380Sal {
|
||||
last_temp: Mutex<f32>,
|
||||
last_fans: Mutex<Vec<u32>>,
|
||||
suppressed_services: Mutex<Vec<String>>,
|
||||
msr_file: Mutex<fs::File>,
|
||||
last_energy: Mutex<(u64, Instant)>,
|
||||
}
|
||||
|
||||
impl DellXps9380Sal {
|
||||
@@ -35,7 +37,6 @@ impl DellXps9380Sal {
|
||||
|
||||
if name == "dell_smm" {
|
||||
temp_path = Some(p.join("temp1_input"));
|
||||
// Discover all fans
|
||||
if let Ok(fan_entries) = fs::read_dir(&p) {
|
||||
for fan_entry in fan_entries.flatten() {
|
||||
let fan_p = fan_entry.path();
|
||||
@@ -54,7 +55,6 @@ impl DellXps9380Sal {
|
||||
}
|
||||
}
|
||||
|
||||
// Discovery for RAPL via powercap
|
||||
if let Ok(entries) = fs::read_dir("/sys/class/powercap") {
|
||||
for entry in entries.flatten() {
|
||||
let p = entry.path();
|
||||
@@ -72,6 +72,9 @@ impl DellXps9380Sal {
|
||||
|
||||
let rapl_base = rapl_base_path.context("Could not find RAPL package-0 path in powercap")?;
|
||||
let freq_path = PathBuf::from("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq");
|
||||
|
||||
let msr_file = fs::OpenOptions::new().read(true).write(true).open("/dev/cpu/0/msr")
|
||||
.context("Failed to open /dev/cpu/0/msr. Is the 'msr' module loaded?")?;
|
||||
|
||||
Ok(Self {
|
||||
temp_path: temp_path.context("Could not find dell_smm temperature path")?,
|
||||
@@ -84,68 +87,64 @@ impl DellXps9380Sal {
|
||||
last_temp: Mutex::new(0.0),
|
||||
last_fans: Mutex::new(Vec::new()),
|
||||
suppressed_services: Mutex::new(Vec::new()),
|
||||
msr_file: Mutex::new(msr_file),
|
||||
last_energy: Mutex::new((0, Instant::now())),
|
||||
})
|
||||
}
|
||||
|
||||
fn read_msr(&self, msr: u32) -> Result<u64> {
|
||||
use std::os::unix::fs::FileExt;
|
||||
let mut buf = [0u8; 8];
|
||||
let file = self.msr_file.lock().unwrap();
|
||||
file.read_at(&mut buf, msr as u64)?;
|
||||
Ok(u64::from_le_bytes(buf))
|
||||
}
|
||||
|
||||
fn write_msr(&self, msr: u32, val: u64) -> Result<()> {
|
||||
use std::os::unix::fs::FileExt;
|
||||
let file = self.msr_file.lock().unwrap();
|
||||
file.write_at(&val.to_le_bytes(), msr as u64)?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl PreflightAuditor for DellXps9380Sal {
|
||||
fn audit(&self) -> Box<dyn Iterator<Item = AuditStep> + '_> {
|
||||
let mut steps = Vec::new();
|
||||
|
||||
// 1. Root check
|
||||
steps.push(AuditStep {
|
||||
description: "Root Privileges".to_string(),
|
||||
outcome: if unsafe { libc::getuid() } == 0 { Ok(()) } else { Err(AuditError::RootRequired) }
|
||||
});
|
||||
|
||||
// 2. Kernel modules check (simplified check via sysfs/proc)
|
||||
let modules = ["dell_smm_hwmon", "msr", "intel_rapl_msr"];
|
||||
for mod_name in modules {
|
||||
let path = format!("/sys/module/{}", mod_name);
|
||||
steps.push(AuditStep {
|
||||
description: format!("Kernel Module: {}", mod_name),
|
||||
outcome: if PathBuf::from(path).exists() { Ok(()) } else {
|
||||
Err(AuditError::ToolMissing(format!("Module '{}' not loaded. Run 'sudo modprobe {}'", mod_name, mod_name)))
|
||||
Err(AuditError::ToolMissing(format!("Module '{}' not loaded.", mod_name)))
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// 3. Kernel parameters check
|
||||
let cmdline = fs::read_to_string("/proc/cmdline").unwrap_or_default();
|
||||
steps.push(AuditStep {
|
||||
description: "Kernel Param: dell_smm_hwmon.ignore_dmi=1".to_string(),
|
||||
outcome: if cmdline.contains("dell_smm_hwmon.ignore_dmi=1") { Ok(()) } else {
|
||||
Err(AuditError::MissingKernelParam("dell_smm_hwmon.ignore_dmi=1".to_string()))
|
||||
}
|
||||
});
|
||||
steps.push(AuditStep {
|
||||
description: "Kernel Param: dell_smm_hwmon.restricted=0".to_string(),
|
||||
outcome: if cmdline.contains("dell_smm_hwmon.restricted=0") { Ok(()) } else {
|
||||
Err(AuditError::MissingKernelParam("dell_smm_hwmon.restricted=0".to_string()))
|
||||
}
|
||||
});
|
||||
steps.push(AuditStep {
|
||||
description: "Kernel Param: msr.allow_writes=on".to_string(),
|
||||
outcome: if cmdline.contains("msr.allow_writes=on") { Ok(()) } else {
|
||||
Err(AuditError::MissingKernelParam("msr.allow_writes=on".to_string()))
|
||||
}
|
||||
});
|
||||
let params = [
|
||||
("dell_smm_hwmon.ignore_dmi=1", "dell_smm_hwmon.ignore_dmi=1"),
|
||||
("dell_smm_hwmon.restricted=0", "dell_smm_hwmon.restricted=0"),
|
||||
("msr.allow_writes=on", "msr.allow_writes=on"),
|
||||
];
|
||||
for (label, p) in params {
|
||||
steps.push(AuditStep {
|
||||
description: format!("Kernel Param: {}", label),
|
||||
outcome: if cmdline.contains(p) { Ok(()) } else { Err(AuditError::MissingKernelParam(p.to_string())) }
|
||||
});
|
||||
}
|
||||
|
||||
// 4. Lockdown check
|
||||
let lockdown = fs::read_to_string("/sys/kernel/security/lockdown").unwrap_or_default();
|
||||
steps.push(AuditStep {
|
||||
description: "Kernel Lockdown Status".to_string(),
|
||||
outcome: if lockdown.contains("[none]") || lockdown.is_empty() { Ok(()) } else {
|
||||
Err(AuditError::KernelIncompatible("Kernel is in lockdown mode. Set to 'none' to allow MSR/SMM writes.".to_string()))
|
||||
}
|
||||
});
|
||||
|
||||
// 5. Check AC power
|
||||
let ac_status = fs::read_to_string("/sys/class/power_supply/AC/online").unwrap_or_else(|_| "0".to_string());
|
||||
steps.push(AuditStep {
|
||||
description: "AC Power Connection".to_string(),
|
||||
outcome: if ac_status.trim() == "1" { Ok(()) } else {
|
||||
Err(AuditError::AcPowerMissing("System must be on AC power for benchmarking".to_string()))
|
||||
Err(AuditError::AcPowerMissing("System must be on AC power".to_string()))
|
||||
}
|
||||
});
|
||||
|
||||
@@ -154,12 +153,11 @@ impl PreflightAuditor for DellXps9380Sal {
|
||||
}
|
||||
|
||||
impl EnvironmentGuard for DellXps9380Sal {
|
||||
fn suppress(&mut self) -> Result<()> {
|
||||
fn suppress(&self) -> Result<()> {
|
||||
let services = ["tlp", "thermald", "i8kmon"];
|
||||
let mut suppressed = self.suppressed_services.lock().unwrap();
|
||||
for s in services {
|
||||
if Command::new("systemctl").args(["is-active", "--quiet", s]).status()?.success() {
|
||||
debug!("Suppressing service: {}", s);
|
||||
Command::new("systemctl").args(["stop", s]).status()?;
|
||||
suppressed.push(s.to_string());
|
||||
}
|
||||
@@ -167,7 +165,7 @@ impl EnvironmentGuard for DellXps9380Sal {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn restore(&mut self) -> Result<()> {
|
||||
fn restore(&self) -> Result<()> {
|
||||
let mut suppressed = self.suppressed_services.lock().unwrap();
|
||||
for s in suppressed.drain(..) {
|
||||
let _ = Command::new("systemctl").args(["start", &s]).status();
|
||||
@@ -176,38 +174,31 @@ impl EnvironmentGuard for DellXps9380Sal {
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for DellXps9380Sal {
|
||||
fn drop(&mut self) {
|
||||
let _ = self.restore();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
impl SensorBus for DellXps9380Sal {
|
||||
fn get_temp(&self) -> Result<f32> {
|
||||
// Enforce 1000ms rate limit for Dell SMM as per GEMINI.md
|
||||
let mut last_poll = self.last_poll.lock().unwrap();
|
||||
let now = Instant::now();
|
||||
|
||||
if now.duration_since(*last_poll) < Duration::from_millis(1000) {
|
||||
return Ok(*self.last_temp.lock().unwrap());
|
||||
}
|
||||
|
||||
let s = fs::read_to_string(&self.temp_path)?;
|
||||
let val = s.trim().parse::<f32>()? / 1000.0;
|
||||
|
||||
*self.last_temp.lock().unwrap() = val;
|
||||
*last_poll = now;
|
||||
|
||||
Ok(val)
|
||||
}
|
||||
|
||||
fn get_power_w(&self) -> Result<f32> {
|
||||
if self.pwr_path.to_string_lossy().contains("energy_uj") {
|
||||
let e1 = fs::read_to_string(&self.pwr_path)?.trim().parse::<u64>()?;
|
||||
std::thread::sleep(Duration::from_millis(100));
|
||||
let mut last = self.last_energy.lock().unwrap();
|
||||
let e2 = fs::read_to_string(&self.pwr_path)?.trim().parse::<u64>()?;
|
||||
Ok((e2.saturating_sub(e1)) as f32 / 100000.0)
|
||||
let t2 = Instant::now();
|
||||
let (e1, t1) = *last;
|
||||
let delta_e = e2.wrapping_sub(e1);
|
||||
let delta_t = t2.duration_since(t1).as_secs_f32();
|
||||
*last = (e2, t2);
|
||||
if delta_t < 0.01 { return Ok(0.0); }
|
||||
Ok((delta_e as f32 / 1_000_000.0) / delta_t)
|
||||
} else {
|
||||
let s = fs::read_to_string(&self.pwr_path)?;
|
||||
Ok(s.trim().parse::<f32>()? / 1000000.0)
|
||||
@@ -217,66 +208,65 @@ impl SensorBus for DellXps9380Sal {
|
||||
fn get_fan_rpms(&self) -> Result<Vec<u32>> {
|
||||
let mut last_poll = self.last_poll.lock().unwrap();
|
||||
let now = Instant::now();
|
||||
|
||||
if now.duration_since(*last_poll) < Duration::from_millis(1000) {
|
||||
return Ok(self.last_fans.lock().unwrap().clone());
|
||||
}
|
||||
|
||||
let mut fans = Vec::new();
|
||||
for path in &self.fan_paths {
|
||||
if let Ok(s) = fs::read_to_string(path) {
|
||||
if let Ok(rpm) = s.trim().parse::<u32>() {
|
||||
fans.push(rpm);
|
||||
}
|
||||
if let Ok(rpm) = s.trim().parse::<u32>() { fans.push(rpm); }
|
||||
}
|
||||
}
|
||||
|
||||
*self.last_fans.lock().unwrap() = fans.clone();
|
||||
*last_poll = now;
|
||||
|
||||
Ok(fans)
|
||||
}
|
||||
|
||||
fn get_freq_mhz(&self) -> Result<f32> {
|
||||
let s = fs::read_to_string(&self.freq_path)?;
|
||||
let val = s.trim().parse::<f32>()? / 1000.0;
|
||||
Ok(val)
|
||||
Ok(s.trim().parse::<f32>()? / 1000.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl ActuatorBus for DellXps9380Sal {
|
||||
fn set_fan_mode(&self, mode: &str) -> Result<()> {
|
||||
match mode {
|
||||
"max" | "Manual" => {
|
||||
Command::new("dell-bios-fan-control").arg("0").status()?;
|
||||
}
|
||||
"auto" | "Auto" => {
|
||||
Command::new("dell-bios-fan-control").arg("1").status()?;
|
||||
}
|
||||
_ => {
|
||||
debug!("Unknown fan mode requested: {}", mode);
|
||||
}
|
||||
"max" | "Manual" => { Command::new("dell-bios-fan-control").arg("0").status()?; }
|
||||
"auto" | "Auto" => { Command::new("dell-bios-fan-control").arg("1").status()?; }
|
||||
_ => { debug!("Unknown fan mode: {}", mode); }
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn set_sustained_power_limit(&self, watts: f32) -> Result<()> {
|
||||
let uw = (watts * 1_000_000.0) as u64;
|
||||
fs::write(&self.pl1_path, uw.to_string())?;
|
||||
fs::write(&self.pl1_path, ((watts * 1_000_000.0) as u64).to_string())?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn set_burst_power_limit(&self, watts: f32) -> Result<()> {
|
||||
let uw = (watts * 1_000_000.0) as u64;
|
||||
fs::write(&self.pl2_path, uw.to_string())?;
|
||||
fs::write(&self.pl2_path, ((watts * 1_000_000.0) as u64).to_string())?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl HardwareWatchdog for DellXps9380Sal {
|
||||
fn check_emergency(&self) -> Result<bool> {
|
||||
// Check for thermal throttling or BD PROCHOT
|
||||
// Simplified for now
|
||||
Ok(false)
|
||||
fn get_safety_status(&self) -> Result<SafetyStatus> {
|
||||
let temp = self.get_temp()?;
|
||||
if temp > 98.0 {
|
||||
return Ok(SafetyStatus::EmergencyAbort(format!("Thermal Runaway: {:.1}°C", temp)));
|
||||
}
|
||||
if let Ok(msr_val) = self.read_msr(0x1FC) {
|
||||
if (msr_val & 0x1) != 0 && temp < 85.0 {
|
||||
let _ = self.write_msr(0x1FC, msr_val & !0x1);
|
||||
return Ok(SafetyStatus::Warning("BD PROCHOT Latch Cleared".to_string()));
|
||||
}
|
||||
}
|
||||
Ok(SafetyStatus::Nominal)
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for DellXps9380Sal {
|
||||
fn drop(&mut self) {
|
||||
let _ = self.restore();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,19 +2,21 @@ use anyhow::{Result, anyhow};
|
||||
use std::path::Path;
|
||||
use std::fs;
|
||||
use std::time::{Duration, Instant};
|
||||
use std::thread;
|
||||
use std::process::Command;
|
||||
use tracing::{debug};
|
||||
use std::sync::mpsc;
|
||||
use tracing::{debug, warn};
|
||||
use std::sync::Mutex;
|
||||
|
||||
use crate::sal::traits::{SensorBus, ActuatorBus, EnvironmentGuard, HardwareWatchdog, PreflightAuditor, AuditStep, AuditError};
|
||||
use crate::sal::traits::{SensorBus, ActuatorBus, EnvironmentGuard, HardwareWatchdog, PreflightAuditor, AuditStep, AuditError, SafetyStatus};
|
||||
use crate::sal::heuristic::discovery::SystemFactSheet;
|
||||
use crate::sal::heuristic::schema::HardwareDb;
|
||||
|
||||
pub struct GenericLinuxSal {
|
||||
fact_sheet: SystemFactSheet,
|
||||
db: HardwareDb,
|
||||
suppressed_services: Vec<String>,
|
||||
suppressed_services: Mutex<Vec<String>>,
|
||||
last_valid_temp: Mutex<(f32, Instant)>,
|
||||
current_pl1: Mutex<f32>,
|
||||
last_energy: Mutex<(u64, Instant)>,
|
||||
}
|
||||
|
||||
impl GenericLinuxSal {
|
||||
@@ -22,7 +24,10 @@ impl GenericLinuxSal {
|
||||
Self {
|
||||
fact_sheet,
|
||||
db,
|
||||
suppressed_services: Vec::new(),
|
||||
suppressed_services: Mutex::new(Vec::new()),
|
||||
last_valid_temp: Mutex::new((0.0, Instant::now())),
|
||||
current_pl1: Mutex::new(15.0),
|
||||
last_energy: Mutex::new((0, Instant::now())),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -30,33 +35,18 @@ impl GenericLinuxSal {
|
||||
self.fact_sheet.vendor.to_lowercase().contains("dell")
|
||||
}
|
||||
|
||||
fn read_sysfs_timeout(&self, path: &Path, timeout: Duration) -> Result<String> {
|
||||
let (tx, rx) = mpsc::channel();
|
||||
let path_buf = path.to_path_buf();
|
||||
|
||||
thread::spawn(move || {
|
||||
let res = fs::read_to_string(path_buf).map(|s| s.trim().to_string());
|
||||
let _ = tx.send(res);
|
||||
});
|
||||
|
||||
match rx.recv_timeout(timeout) {
|
||||
Ok(res) => res.map_err(|e| anyhow!("Failed to read sysfs: {}", e)),
|
||||
Err(_) => Err(anyhow!("Timeout reading sysfs path: {:?}", path)),
|
||||
}
|
||||
/// Read sysfs safely. We removed the thread-per-read timeout logic
|
||||
/// as it was inefficient. sysfs reads are generally fast enough.
|
||||
fn read_sysfs(&self, path: &Path) -> Result<String> {
|
||||
fs::read_to_string(path).map(|s| s.trim().to_string()).map_err(|e| anyhow!(e))
|
||||
}
|
||||
}
|
||||
|
||||
impl PreflightAuditor for GenericLinuxSal {
|
||||
fn audit(&self) -> Box<dyn Iterator<Item = AuditStep> + '_> {
|
||||
let mut steps = Vec::new();
|
||||
|
||||
// 1. Static DB checks
|
||||
for check in &self.db.preflight_checks {
|
||||
let status = Command::new("sh")
|
||||
.arg("-c")
|
||||
.arg(&check.check_cmd)
|
||||
.status();
|
||||
|
||||
let status = Command::new("sh").arg("-c").arg(&check.check_cmd).status();
|
||||
steps.push(AuditStep {
|
||||
description: check.name.clone(),
|
||||
outcome: match status {
|
||||
@@ -65,8 +55,6 @@ impl PreflightAuditor for GenericLinuxSal {
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// 2. Conflict checks (Critical only)
|
||||
for conflict_id in &self.fact_sheet.active_conflicts {
|
||||
if let Some(conflict) = self.db.conflicts.iter().find(|c| &c.id == conflict_id) {
|
||||
if conflict.severity == "Critical" {
|
||||
@@ -77,7 +65,6 @@ impl PreflightAuditor for GenericLinuxSal {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Box::new(steps.into_iter())
|
||||
}
|
||||
}
|
||||
@@ -86,31 +73,32 @@ impl SensorBus for GenericLinuxSal {
|
||||
fn get_temp(&self) -> Result<f32> {
|
||||
let path = self.fact_sheet.temp_path.as_ref()
|
||||
.ok_or_else(|| anyhow!("No temperature sensor path found"))?;
|
||||
let content = self.read_sysfs_timeout(path, Duration::from_millis(200))?;
|
||||
let milli_celsius: f32 = content.parse()?;
|
||||
Ok(milli_celsius / 1000.0)
|
||||
let content = self.read_sysfs(path)?;
|
||||
let temp = content.parse::<f32>()? / 1000.0;
|
||||
let mut last = self.last_valid_temp.lock().unwrap();
|
||||
if (temp - last.0).abs() > 0.01 { *last = (temp, Instant::now()); }
|
||||
Ok(temp)
|
||||
}
|
||||
|
||||
fn get_power_w(&self) -> Result<f32> {
|
||||
let rapl_path = self.fact_sheet.rapl_paths.first()
|
||||
.ok_or_else(|| anyhow!("No RAPL path found"))?;
|
||||
let energy_path = rapl_path.join("energy_uj");
|
||||
|
||||
let e1: u64 = self.read_sysfs_timeout(&energy_path, Duration::from_millis(200))?.parse()?;
|
||||
let t1 = Instant::now();
|
||||
thread::sleep(Duration::from_millis(100));
|
||||
let e2: u64 = self.read_sysfs_timeout(&energy_path, Duration::from_millis(200))?.parse()?;
|
||||
let mut last = self.last_energy.lock().unwrap();
|
||||
let e2: u64 = self.read_sysfs(&energy_path)?.parse()?;
|
||||
let t2 = Instant::now();
|
||||
|
||||
let (e1, t1) = *last;
|
||||
let delta_e = e2.wrapping_sub(e1);
|
||||
let delta_t = t2.duration_since(t1).as_secs_f32();
|
||||
*last = (e2, t2);
|
||||
if delta_t < 0.01 { return Ok(0.0); }
|
||||
Ok((delta_e as f32 / 1_000_000.0) / delta_t)
|
||||
}
|
||||
|
||||
fn get_fan_rpms(&self) -> Result<Vec<u32>> {
|
||||
let mut rpms = Vec::new();
|
||||
for path in &self.fact_sheet.fan_paths {
|
||||
if let Ok(content) = self.read_sysfs_timeout(path, Duration::from_millis(200)) {
|
||||
if let Ok(content) = self.read_sysfs(path) {
|
||||
if let Ok(rpm) = content.parse() { rpms.push(rpm); }
|
||||
}
|
||||
}
|
||||
@@ -120,10 +108,8 @@ impl SensorBus for GenericLinuxSal {
|
||||
fn get_freq_mhz(&self) -> Result<f32> {
|
||||
let path = Path::new("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq");
|
||||
if path.exists() {
|
||||
let khz: f32 = self.read_sysfs_timeout(path, Duration::from_millis(200))?.parse()?;
|
||||
Ok(khz / 1000.0)
|
||||
Ok(self.read_sysfs(path)?.parse::<f32>()? / 1000.0)
|
||||
} else {
|
||||
// Fallback: parse /proc/cpuinfo
|
||||
let cpuinfo = fs::read_to_string("/proc/cpuinfo")?;
|
||||
for line in cpuinfo.lines() {
|
||||
if line.starts_with("cpu MHz") {
|
||||
@@ -149,38 +135,32 @@ impl ActuatorBus for GenericLinuxSal {
|
||||
let parts: Vec<&str> = cmd_str.split_whitespace().collect();
|
||||
Command::new(parts[0]).args(&parts[1..]).status()?;
|
||||
Ok(())
|
||||
} else { Err(anyhow!("Dell fan command missing in DB")) }
|
||||
} else {
|
||||
debug!("Fan control not implemented for non-Dell systems yet");
|
||||
Ok(())
|
||||
}
|
||||
} else { Err(anyhow!("Dell fan command missing")) }
|
||||
} else { Ok(()) }
|
||||
}
|
||||
|
||||
fn set_sustained_power_limit(&self, watts: f32) -> Result<()> {
|
||||
let rapl_path = self.fact_sheet.rapl_paths.first()
|
||||
.ok_or_else(|| anyhow!("No RAPL path found for PL1"))?;
|
||||
let path = rapl_path.join("constraint_0_power_limit_uw");
|
||||
fs::write(path, ((watts * 1_000_000.0) as u64).to_string())?;
|
||||
let rapl_path = self.fact_sheet.rapl_paths.first().ok_or_else(|| anyhow!("No PL1 path"))?;
|
||||
fs::write(rapl_path.join("constraint_0_power_limit_uw"), ((watts * 1_000_000.0) as u64).to_string())?;
|
||||
*self.current_pl1.lock().unwrap() = watts;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn set_burst_power_limit(&self, watts: f32) -> Result<()> {
|
||||
let rapl_path = self.fact_sheet.rapl_paths.first()
|
||||
.ok_or_else(|| anyhow!("No RAPL path found for PL2"))?;
|
||||
let path = rapl_path.join("constraint_1_power_limit_uw");
|
||||
fs::write(path, ((watts * 1_000_000.0) as u64).to_string())?;
|
||||
let rapl_path = self.fact_sheet.rapl_paths.first().ok_or_else(|| anyhow!("No PL2 path"))?;
|
||||
fs::write(rapl_path.join("constraint_1_power_limit_uw"), ((watts * 1_000_000.0) as u64).to_string())?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl EnvironmentGuard for GenericLinuxSal {
|
||||
fn suppress(&mut self) -> Result<()> {
|
||||
fn suppress(&self) -> Result<()> {
|
||||
let mut suppressed = self.suppressed_services.lock().unwrap();
|
||||
for conflict_id in &self.fact_sheet.active_conflicts {
|
||||
if let Some(conflict) = self.db.conflicts.iter().find(|c| &c.id == conflict_id) {
|
||||
for service in &conflict.services {
|
||||
debug!("Stopping service: {}", service);
|
||||
if Command::new("systemctl").arg("stop").arg(service).status()?.success() {
|
||||
self.suppressed_services.push(service.clone());
|
||||
suppressed.push(service.clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -188,31 +168,30 @@ impl EnvironmentGuard for GenericLinuxSal {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn restore(&mut self) -> Result<()> {
|
||||
for service in self.suppressed_services.drain(..) {
|
||||
debug!("Starting service: {}", service);
|
||||
fn restore(&self) -> Result<()> {
|
||||
let mut suppressed = self.suppressed_services.lock().unwrap();
|
||||
for service in suppressed.drain(..) {
|
||||
let _ = Command::new("systemctl").arg("start").arg(service).status();
|
||||
}
|
||||
if self.is_dell() {
|
||||
let _ = self.set_fan_mode("auto");
|
||||
}
|
||||
if self.is_dell() { let _ = self.set_fan_mode("auto"); }
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl HardwareWatchdog for GenericLinuxSal {
|
||||
fn check_emergency(&self) -> Result<bool> {
|
||||
if let Ok(temp) = self.get_temp() {
|
||||
if temp > 100.0 {
|
||||
return Ok(true);
|
||||
}
|
||||
fn get_safety_status(&self) -> Result<SafetyStatus> {
|
||||
let temp = self.get_temp()?;
|
||||
if temp > 100.0 {
|
||||
return Ok(SafetyStatus::EmergencyAbort(format!("Thermal runaway: {:.1}°C", temp)));
|
||||
}
|
||||
Ok(false)
|
||||
let last = self.last_valid_temp.lock().unwrap();
|
||||
if last.1.elapsed() > Duration::from_secs(5) {
|
||||
return Ok(SafetyStatus::EmergencyAbort("Temperature sensor stalled".to_string()));
|
||||
}
|
||||
Ok(SafetyStatus::Nominal)
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for GenericLinuxSal {
|
||||
fn drop(&mut self) {
|
||||
let _ = self.restore();
|
||||
}
|
||||
fn drop(&mut self) { let _ = self.restore(); }
|
||||
}
|
||||
|
||||
@@ -31,6 +31,7 @@ pub struct Conflict {
|
||||
#[derive(Debug, Deserialize, Clone)]
|
||||
pub struct Ecosystem {
|
||||
pub vendor_regex: String,
|
||||
pub product_regex: Option<String>,
|
||||
pub polling_cap_ms: Option<u64>,
|
||||
pub drivers: Option<Vec<String>>,
|
||||
pub fan_manual_mode_cmd: Option<String>,
|
||||
@@ -46,6 +47,7 @@ pub struct Ecosystem {
|
||||
pub fan_boost_path: Option<String>,
|
||||
pub ec_tool: Option<String>,
|
||||
pub optimization: Option<String>,
|
||||
pub help_text: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, Clone)]
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
use super::traits::{PreflightAuditor, EnvironmentGuard, SensorBus, ActuatorBus, HardwareWatchdog, AuditStep};
|
||||
use super::traits::{PreflightAuditor, EnvironmentGuard, SensorBus, ActuatorBus, HardwareWatchdog, AuditStep, PlatformSal, SafetyStatus};
|
||||
use anyhow::Result;
|
||||
|
||||
pub struct MockSal;
|
||||
@@ -26,10 +26,10 @@ impl PreflightAuditor for MockSal {
|
||||
}
|
||||
|
||||
impl EnvironmentGuard for MockSal {
|
||||
fn suppress(&mut self) -> Result<()> {
|
||||
fn suppress(&self) -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
fn restore(&mut self) -> Result<()> {
|
||||
fn restore(&self) -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -62,7 +62,7 @@ impl ActuatorBus for MockSal {
|
||||
}
|
||||
|
||||
impl HardwareWatchdog for MockSal {
|
||||
fn check_emergency(&self) -> Result<bool> {
|
||||
Ok(false)
|
||||
fn get_safety_status(&self) -> Result<SafetyStatus> {
|
||||
Ok(SafetyStatus::Nominal)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -49,8 +49,17 @@ impl<T: PreflightAuditor + ?Sized> PreflightAuditor for Arc<T> {
|
||||
|
||||
/// Suppresses conflicting daemons (tlp, thermald).
|
||||
pub trait EnvironmentGuard: Send + Sync {
|
||||
fn suppress(&mut self) -> Result<()>;
|
||||
fn restore(&mut self) -> Result<()>;
|
||||
fn suppress(&self) -> Result<()>;
|
||||
fn restore(&self) -> Result<()>;
|
||||
}
|
||||
|
||||
impl<T: EnvironmentGuard + ?Sized> EnvironmentGuard for Arc<T> {
|
||||
fn suppress(&self) -> Result<()> {
|
||||
(**self).suppress()
|
||||
}
|
||||
fn restore(&self) -> Result<()> {
|
||||
(**self).restore()
|
||||
}
|
||||
}
|
||||
|
||||
/// Read-only interface for standardized metrics.
|
||||
@@ -97,15 +106,23 @@ impl<T: ActuatorBus + ?Sized> ActuatorBus for Arc<T> {
|
||||
|
||||
/// Concurrent monitor for catastrophic states.
|
||||
pub trait HardwareWatchdog: Send + Sync {
|
||||
fn check_emergency(&self) -> Result<bool>;
|
||||
fn get_safety_status(&self) -> Result<SafetyStatus>;
|
||||
}
|
||||
|
||||
impl<T: HardwareWatchdog + ?Sized> HardwareWatchdog for Arc<T> {
|
||||
fn check_emergency(&self) -> Result<bool> {
|
||||
(**self).check_emergency()
|
||||
fn get_safety_status(&self) -> Result<SafetyStatus> {
|
||||
(**self).get_safety_status()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub enum SafetyStatus {
|
||||
Nominal,
|
||||
Warning(String),
|
||||
Critical(String),
|
||||
EmergencyAbort(String),
|
||||
}
|
||||
|
||||
/// Aggregate trait for a complete platform implementation.
|
||||
pub trait PlatformSal: PreflightAuditor + SensorBus + ActuatorBus + EnvironmentGuard + HardwareWatchdog {}
|
||||
|
||||
|
||||
@@ -5,6 +5,7 @@ use ratatui::{
|
||||
widgets::{Block, Borders, List, ListItem, Paragraph, Chart, Dataset, Axis, BorderType, GraphType},
|
||||
symbols::Marker,
|
||||
Frame,
|
||||
prelude::Stylize,
|
||||
};
|
||||
use crate::mediator::TelemetryState;
|
||||
use crate::ui::theme::*;
|
||||
@@ -83,6 +84,55 @@ pub fn draw_dashboard(
|
||||
draw_freq_graph(f, right_side_chunks[2], state);
|
||||
|
||||
draw_logs(f, chunks[3], ui_state);
|
||||
|
||||
if state.is_emergency {
|
||||
draw_emergency_overlay(f, area, state);
|
||||
}
|
||||
}
|
||||
|
||||
fn draw_emergency_overlay(f: &mut Frame, area: Rect, state: &TelemetryState) {
|
||||
let block = Block::default()
|
||||
.borders(Borders::ALL)
|
||||
.border_type(BorderType::Double)
|
||||
.border_style(Style::default().fg(Color::Red).add_modifier(Modifier::BOLD))
|
||||
.bg(Color::Black)
|
||||
.title(" 🚨 EMERGENCY ABORT 🚨 ");
|
||||
|
||||
let area = centered_rect(60, 20, area);
|
||||
let inner = block.inner(area);
|
||||
f.render_widget(block, area);
|
||||
|
||||
let reason = state.emergency_reason.as_deref().unwrap_or("Unknown safety trigger");
|
||||
let text = vec![
|
||||
Line::from(vec![Span::styled("CRITICAL SAFETY LIMIT TRIGGERED", Style::default().fg(Color::Red).add_modifier(Modifier::BOLD))]),
|
||||
Line::from(""),
|
||||
Line::from(vec![Span::raw("Reason: "), Span::styled(reason, Style::default().fg(Color::Yellow))]),
|
||||
Line::from(""),
|
||||
Line::from("Hardware has been restored to safe defaults."),
|
||||
Line::from("Exiting in 1 second..."),
|
||||
];
|
||||
|
||||
f.render_widget(Paragraph::new(text).alignment(ratatui::layout::Alignment::Center), inner);
|
||||
}
|
||||
|
||||
fn centered_rect(percent_x: u16, percent_y: u16, r: Rect) -> Rect {
|
||||
let popup_layout = Layout::default()
|
||||
.direction(Direction::Vertical)
|
||||
.constraints([
|
||||
Constraint::Percentage((100 - percent_y) / 2),
|
||||
Constraint::Percentage(percent_y),
|
||||
Constraint::Percentage((100 - percent_y) / 2),
|
||||
])
|
||||
.split(r);
|
||||
|
||||
Layout::default()
|
||||
.direction(Direction::Horizontal)
|
||||
.constraints([
|
||||
Constraint::Percentage((100 - percent_x) / 2),
|
||||
Constraint::Percentage(percent_x),
|
||||
Constraint::Percentage((100 - percent_x) / 2),
|
||||
])
|
||||
.split(popup_layout[1])[1]
|
||||
}
|
||||
|
||||
fn draw_header(f: &mut Frame, area: Rect, state: &TelemetryState) {
|
||||
|
||||
Reference in New Issue
Block a user