nvrl/ember-tune-rs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

update docs + agents

Browse Source
This commit is contained in:
Nils Pukropp
2026-02-27 17:04:47 +01:00
parent fe1f58b5ce
commit 4f54fd81ce
15 changed files with 508 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

90
src/sal/dell_xps_9380.rs
View File

@@ -5,9 +5,10 @@ use std::fs;
use std::path::{PathBuf};
use std::time::{Duration, Instant};
use std::sync::Mutex;
use tracing::{debug};
use tracing::{debug, warn};
use crate::sal::heuristic::discovery::SystemFactSheet;
/// Implementation of the System Abstraction Layer for the Dell XPS 13 9380.
pub struct DellXps9380Sal {
ctx: EnvironmentCtx,
fact_sheet: SystemFactSheet,
@@ -23,9 +24,16 @@ pub struct DellXps9380Sal {
suppressed_services: Mutex<Vec<String>>,
msr_file: Mutex<fs::File>,
last_energy: Mutex<(u64, Instant)>,
last_watts: Mutex<f32>,
// --- Original State for Restoration ---
original_pl1: Mutex<Option<u64>>,
original_pl2: Mutex<Option<u64>>,
original_fan_mode: Mutex<Option<String>>,
}
impl DellXps9380Sal {
/// Initializes the Dell SAL, opening the MSR interface and discovering sensors.
pub fn init(ctx: EnvironmentCtx, facts: SystemFactSheet) -> Result<Self> {
let temp_path = facts.temp_path.clone().context("Dell SAL requires temperature sensor")?;
let pwr_base = facts.rapl_paths.first().cloned().context("Dell SAL requires RAPL interface")?;
@@ -52,8 +60,12 @@ impl DellXps9380Sal {
suppressed_services: Mutex::new(Vec::new()),
msr_file: Mutex::new(msr_file),
last_energy: Mutex::new((initial_energy, Instant::now())),
last_watts: Mutex::new(0.0),
fact_sheet: facts,
ctx,
original_pl1: Mutex::new(None),
original_pl2: Mutex::new(None),
original_fan_mode: Mutex::new(None),
})
}
@@ -81,6 +93,22 @@ impl PreflightAuditor for DellXps9380Sal {
outcome: if unsafe { libc::getuid() } == 0 { Ok(()) } else { Err(AuditError::RootRequired) }
});
// RAPL Lock Check (MSR 0x610)
let rapl_lock = match self.read_msr(0x610) {
Ok(val) => {
if (val & (1 << 63)) != 0 {
Err(AuditError::KernelIncompatible("RAPL Registers are locked by BIOS. Power limit tuning is impossible.".to_string()))
} else {
Ok(())
}
},
Err(e) => Err(AuditError::ToolMissing(format!("Cannot read MSR 0x610: {}", e))),
};
steps.push(AuditStep {
description: "MSR 0x610 RAPL Lock Status".to_string(),
outcome: rapl_lock,
});
let modules = ["dell_smm_hwmon", "msr", "intel_rapl_msr"];
for mod_name in modules {
let path = self.ctx.sysfs_base.join(format!("sys/module/{}", mod_name));
@@ -115,23 +143,24 @@ impl PreflightAuditor for DellXps9380Sal {
}
});
let tool_check = self.fact_sheet.paths.tools.contains_key("dell_fan_ctrl");
steps.push(AuditStep {
description: "Dell Fan Control Tool".to_string(),
outcome: if tool_check { Ok(()) } else { Err(AuditError::ToolMissing("dell-bios-fan-control not found in PATH".to_string())) }
});
Box::new(steps.into_iter())
}
}
impl EnvironmentGuard for DellXps9380Sal {
fn suppress(&self) -> Result<()> {
let mut suppressed = self.suppressed_services.lock().unwrap();
if let Ok(pl1) = fs::read_to_string(&self.pl1_path) {
*self.original_pl1.lock().unwrap() = pl1.trim().parse().ok();
}
if let Ok(pl2) = fs::read_to_string(&self.pl2_path) {
*self.original_pl2.lock().unwrap() = pl2.trim().parse().ok();
}
*self.original_fan_mode.lock().unwrap() = Some("1".to_string());
let services = ["tlp", "thermald", "i8kmon"];
let mut suppressed = self.suppressed_services.lock().unwrap();
for s in services {
if self.ctx.runner.run("systemctl", &["is-active", "--quiet", s]).is_ok() {
debug!("Suppressing service: {}", s);
let _ = self.ctx.runner.run("systemctl", &["stop", s]);
suppressed.push(s.to_string());
}
@@ -140,6 +169,15 @@ impl EnvironmentGuard for DellXps9380Sal {
}
fn restore(&self) -> Result<()> {
if let Some(pl1) = *self.original_pl1.lock().unwrap() {
let _ = fs::write(&self.pl1_path, pl1.to_string());
}
if let Some(pl2) = *self.original_pl2.lock().unwrap() {
let _ = fs::write(&self.pl2_path, pl2.to_string());
}
if let Some(tool_path) = self.fact_sheet.paths.tools.get("dell_fan_ctrl") {
let _ = self.ctx.runner.run(&tool_path.to_string_lossy(), &["1"]);
}
let mut suppressed = self.suppressed_services.lock().unwrap();
for s in suppressed.drain(..) {
let _ = self.ctx.runner.run("systemctl", &["start", &s]);
@@ -167,16 +205,25 @@ impl SensorBus for DellXps9380Sal {
let energy_path = rapl_base.join("energy_uj");
if energy_path.exists() {
let mut last = self.last_energy.lock().unwrap();
let mut last_energy = self.last_energy.lock().unwrap();
let mut last_watts = self.last_watts.lock().unwrap();
let e2_str = fs::read_to_string(&energy_path)?;
let e2 = e2_str.trim().parse::<u64>()?;
let t2 = Instant::now();
let (e1, t1) = *last;
let (e1, t1) = *last_energy;
let delta_e = e2.wrapping_sub(e1);
let delta_t = t2.duration_since(t1).as_secs_f32();
*last = (e2, t2);
if delta_t < 0.05 { return Ok(0.0); }
Ok((delta_e as f32 / 1_000_000.0) / delta_t)
if delta_t < 0.1 {
return Ok(*last_watts); // Return cached if polled too fast
}
let watts = (delta_e as f32 / 1_000_000.0) / delta_t;
*last_energy = (e2, t2);
*last_watts = watts;
Ok(watts)
} else {
let s = fs::read_to_string(&self.pwr_path)?;
Ok(s.trim().parse::<f32>()? / 1000000.0)
@@ -204,6 +251,12 @@ impl SensorBus for DellXps9380Sal {
let s = fs::read_to_string(&self.freq_path)?;
Ok(s.trim().parse::<f32>()? / 1000.0)
}
fn get_throttling_status(&self) -> Result<bool> {
// MSR 0x19C bit 0 is "Thermal Status", bit 1 is "Thermal Log"
let val = self.read_msr(0x19C)?;
Ok((val & 0x1) != 0)
}
}
impl ActuatorBus for DellXps9380Sal {
@@ -220,14 +273,7 @@ impl ActuatorBus for DellXps9380Sal {
Ok(())
}
fn set_fan_speed(&self, speed: FanSpeedPercentage) -> Result<()> {
let tool_path = self.fact_sheet.paths.tools.get("dell_fan_ctrl")
.ok_or_else(|| anyhow!("Dell fan control tool not found in PATH"))?;
let tool_str = tool_path.to_string_lossy();
if speed.as_u8() > 50 {
let _ = self.ctx.runner.run(&tool_str, &["0"]);
}
fn set_fan_speed(&self, _speed: FanSpeedPercentage) -> Result<()> {
Ok(())
}

17
src/sal/generic_linux.rs
View File

@@ -133,6 +133,23 @@ impl SensorBus for GenericLinuxSal {
Err(anyhow!("Could not determine CPU frequency"))
}
}
fn get_throttling_status(&self) -> Result<bool> {
// Fallback: check if any cooling device is active (cur_state > 0)
let cooling_base = self.ctx.sysfs_base.join("sys/class/thermal");
if let Ok(entries) = fs::read_dir(cooling_base) {
for entry in entries.flatten() {
if entry.file_name().to_string_lossy().starts_with("cooling_device") {
if let Ok(state) = fs::read_to_string(entry.path().join("cur_state")) {
if state.trim().parse::<u32>().unwrap_or(0) > 0 {
return Ok(true);
}
}
}
}
}
Ok(false)
}
}
impl ActuatorBus for GenericLinuxSal {

3
src/sal/mock.rs
View File

@@ -54,6 +54,9 @@ impl SensorBus for MockSal {
fn get_freq_mhz(&self) -> Result<f32> {
Ok(3200.0)
}
fn get_throttling_status(&self) -> Result<bool> {
Ok(self.get_temp()? > 90.0)
}
}
impl ActuatorBus for MockSal {

6
src/sal/traits.rs
View File

@@ -140,6 +140,9 @@ pub trait SensorBus: Send + Sync {
/// # Errors
/// Returns an error if `/proc/cpuinfo` or a `cpufreq` sysfs node cannot be read.
fn get_freq_mhz(&self) -> Result<f32>;
/// Returns true if the system is currently thermally throttling.
fn get_throttling_status(&self) -> Result<bool>;
}
impl<T: SensorBus + ?Sized> SensorBus for Arc<T> {
@@ -155,6 +158,9 @@ impl<T: SensorBus + ?Sized> SensorBus for Arc<T> {
fn get_freq_mhz(&self) -> Result<f32> {
(**self).get_freq_mhz()
}
fn get_throttling_status(&self) -> Result<bool> {
(**self).get_throttling_status()
}
}
use crate::sal::safety::{TdpLimitMicroWatts, FanSpeedPercentage};