fixed dangerous states to be applied

src/sal/dell_xps_9380.rs

@@ -22,6 +22,11 @@ pub struct DellXps9380Sal {
     suppressed_services: Mutex<Vec<String>>,
     msr_file: Mutex<fs::File>,
     last_energy: Mutex<(u64, Instant)>,
+
+    // --- Original State for Restoration ---
+    original_pl1: Mutex<Option<u64>>,
+    original_pl2: Mutex<Option<u64>>,
+    original_fan_mode: Mutex<Option<String>>,
 }
 
 impl DellXps9380Sal {
@@ -53,6 +58,9 @@ impl DellXps9380Sal {
             last_energy: Mutex::new((initial_energy, Instant::now())),
             fact_sheet: facts,
             ctx,
+            original_pl1: Mutex::new(None),
+            original_pl2: Mutex::new(None),
+            original_fan_mode: Mutex::new(None),
         })
     }
 
@@ -126,12 +134,25 @@ impl PreflightAuditor for DellXps9380Sal {
 
 impl EnvironmentGuard for DellXps9380Sal {
     fn suppress(&self) -> Result<()> {
+        // 1. Snapshot Power Limits
+        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();
+        }
+
+        // 2. Snapshot Fan Mode (Assumption: Dell BIOS Fan Control is active)
+        // We can't easily read current state of dell-bios-fan-control, so we assume 'auto' (1)
+        *self.original_fan_mode.lock().unwrap() = Some("1".to_string());
+
+        // 3. Stop Services
         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);
-                self.ctx.runner.run("systemctl", &["stop", s])?;
+                let _ = self.ctx.runner.run("systemctl", &["stop", s]);
                 suppressed.push(s.to_string());
             }
         }
@@ -139,6 +160,20 @@ impl EnvironmentGuard for DellXps9380Sal {
     }
 
     fn restore(&self) -> Result<()> {
+        // 1. Restore Power Limits
+        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());
+        }
+
+        // 2. Restore Fan Mode (BIOS Control)
+        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"]);
+        }
+
+        // 3. Restart Services
         let mut suppressed = self.suppressed_services.lock().unwrap();
         for s in suppressed.drain(..) {
             let _ = self.ctx.runner.run("systemctl", &["start", &s]);
@@ -162,17 +197,23 @@ impl SensorBus for DellXps9380Sal {
     }
 
     fn get_power_w(&self) -> Result<f32> {
-        if self.pwr_path.to_string_lossy().contains("energy_uj") {
+        // FIX: Ensure we always read from energy_uj if available for delta calculation
+        let rapl_base = self.pl1_path.parent().context("RAPL path error")?;
+        let energy_path = rapl_base.join("energy_uj");
+
+        if energy_path.exists() {
             let mut last = self.last_energy.lock().unwrap();
-            let e2 = fs::read_to_string(&self.pwr_path)?.trim().parse::<u64>()?;
+            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 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); }
+            if delta_t < 0.05 { return Ok(0.0); }
             Ok((delta_e as f32 / 1_000_000.0) / delta_t)
         } else {
+            // Fallback to power1_average if it exists (units are µW)
             let s = fs::read_to_string(&self.pwr_path)?;
             Ok(s.trim().parse::<f32>()? / 1000000.0)
         }