updated

src/sal/heuristic/discovery.rs

@@ -6,7 +6,7 @@ use std::sync::mpsc;
 use std::collections::HashMap;
 use crate::sal::heuristic::schema::{SensorDiscovery, ActuatorDiscovery, Conflict, Discovery, Benchmarking};
 use crate::sys::SyscallRunner;
-use tracing::{debug, warn};
+use tracing::{debug, warn, info};
 
 /// Registry of dynamically discovered paths for configs and tools.
 #[derive(Debug, Clone, Default)]
@@ -24,6 +24,7 @@ pub struct SystemFactSheet {
     pub fan_paths: Vec<PathBuf>,
     pub rapl_paths: Vec<PathBuf>,
     pub active_conflicts: Vec<String>,
+    pub conflict_services: Vec<String>,
     pub paths: PathRegistry,
     pub bench_config: Option<Benchmarking>,
 }
@@ -44,12 +45,17 @@ pub fn discover_facts(
     let rapl_paths = discover_rapl(base_path, &discovery.actuators);
     
     let mut active_conflicts = Vec::new();
+    let mut conflict_services = Vec::new();
     for conflict in conflicts {
+        let mut found_active = false;
         for service in &conflict.services {
             if is_service_active(runner, service) {
-                debug!("Detected active conflict: {} (Service: {})", conflict.id, service);
-                active_conflicts.push(conflict.id.clone());
-                break;
+                if !found_active {
+                    debug!("Detected active conflict: {} (Service: {})", conflict.id, service);
+                    active_conflicts.push(conflict.id.clone());
+                    found_active = true;
+                }
+                conflict_services.push(service.clone());
             }
         }
     }
@@ -57,13 +63,7 @@ pub fn discover_facts(
     let paths = discover_paths(base_path, discovery);
 
     SystemFactSheet {
-        vendor,
-        model,
-        temp_path,
-        fan_paths,
-        rapl_paths,
-        active_conflicts,
-        paths,
+        vendor, model, temp_path, fan_paths, rapl_paths, active_conflicts, conflict_services, paths,
         bench_config: Some(bench_config),
     }
 }
@@ -71,7 +71,6 @@ pub fn discover_facts(
 fn discover_paths(base_path: &Path, discovery: &Discovery) -> PathRegistry {
     let mut registry = PathRegistry::default();
 
-    // 1. Discover Tools via PATH
     for (id, binary_name) in &discovery.tools {
         if let Ok(path) = which::which(binary_name) {
             debug!("Discovered tool: {} -> {:?}", id, path);
@@ -79,7 +78,6 @@ fn discover_paths(base_path: &Path, discovery: &Discovery) -> PathRegistry {
         }
     }
 
-    // 2. Discover Configs via existence check
     for (id, candidates) in &discovery.configs {
         for candidate in candidates {
             let path = if candidate.starts_with('/') {
@@ -104,12 +102,11 @@ fn discover_paths(base_path: &Path, discovery: &Discovery) -> PathRegistry {
     registry
 }
 
-/// Reads DMI information from sysfs with a safety timeout.
 fn read_dmi_info(base_path: &Path) -> (String, String) {
-    let vendor = read_sysfs_with_timeout(&base_path.join("sys/class/dmi/id/sys_vendor"), Duration::from_millis(100))
-        .unwrap_or_else(|| "Unknown".to_string());
-    let model = read_sysfs_with_timeout(&base_path.join("sys/class/dmi/id/product_name"), Duration::from_millis(100))
-        .unwrap_or_else(|| "Unknown".to_string());
+    let vendor = fs::read_to_string(base_path.join("sys/class/dmi/id/sys_vendor"))
+        .map(|s| s.trim().to_string()).unwrap_or_else(|_| "Unknown".to_string());
+    let model = fs::read_to_string(base_path.join("sys/class/dmi/id/product_name"))
+        .map(|s| s.trim().to_string()).unwrap_or_else(|_| "Unknown".to_string());
     (vendor, model)
 }
 
@@ -119,49 +116,62 @@ fn discover_hwmon(base_path: &Path, cfg: &SensorDiscovery) -> (Option<PathBuf>,
     let mut fan_candidates = Vec::new();
 
     let hwmon_base = base_path.join("sys/class/hwmon");
-    let entries = match fs::read_dir(&hwmon_base) {
-        Ok(e) => e,
-        Err(e) => {
-            warn!("Could not read {:?}: {}", hwmon_base, e);
-            return (None, Vec::new());
-        }
-    };
+    let entries = fs::read_dir(&hwmon_base).map_err(|e| {
+        warn!("Could not read {:?}: {}", hwmon_base, e);
+        e
+    }).ok();
 
-    for entry in entries.flatten() {
-        let hwmon_path = entry.path();
-        
-        let driver_name = read_sysfs_with_timeout(&hwmon_path.join("name"), Duration::from_millis(100))
-            .unwrap_or_default();
+    if let Some(entries) = entries {
+        for entry in entries.flatten() {
+            let hwmon_path = entry.path();
+            
+            // # SAFETY: Read driver name directly. This file is virtual and never blocks.
+            // Using a timeout wrapper here was causing discovery to fail if the thread-pool lagged.
+            let driver_name = fs::read_to_string(hwmon_path.join("name"))
+                .map(|s| s.trim().to_string()).unwrap_or_default();
 
-        let priority = cfg.hwmon_priority
-            .iter()
-            .position(|p| p == &driver_name)
-            .unwrap_or(usize::MAX);
+            let priority = cfg.hwmon_priority
+                .iter()
+                .position(|p| driver_name.contains(p))
+                .unwrap_or(usize::MAX);
 
-        if let Ok(hw_entries) = fs::read_dir(&hwmon_path) {
-            for hw_entry in hw_entries.flatten() {
-                let file_name = hw_entry.file_name().into_string().unwrap_or_default();
-                
-                if file_name.starts_with("temp") && file_name.ends_with("_label") {
-                    if let Some(label) = read_sysfs_with_timeout(&hw_entry.path(), Duration::from_millis(100)) {
-                        if cfg.temp_labels.iter().any(|l| label.contains(l)) {
-                            let input_path = hwmon_path.join(file_name.replace("_label", "_input"));
-                            if input_path.exists() {
-                                temp_candidates.push((priority, input_path));
+            if let Ok(hw_entries) = fs::read_dir(&hwmon_path) {
+                for hw_entry in hw_entries.flatten() {
+                    let file_name = hw_entry.file_name().into_string().unwrap_or_default();
+                    
+                    // 1. Temperatures
+                    if file_name.starts_with("temp") && file_name.ends_with("_label") {
+                        if let Some(label) = read_sysfs_with_timeout(&hw_entry.path(), Duration::from_millis(500)) {
+                            if cfg.temp_labels.iter().any(|l| label.contains(l)) {
+                                let input_path = hwmon_path.join(file_name.replace("_label", "_input"));
+                                if input_path.exists() {
+                                    temp_candidates.push((priority, input_path));
+                                }
                             }
                         }
                     }
-                }
 
-                if file_name.starts_with("fan") && file_name.ends_with("_label") {
-                    if let Some(label) = read_sysfs_with_timeout(&hw_entry.path(), Duration::from_millis(100)) {
-                        if cfg.fan_labels.iter().any(|l| label.contains(l)) {
-                            let input_path = hwmon_path.join(file_name.replace("_label", "_input"));
-                            if input_path.exists() {
-                                fan_candidates.push((priority, input_path));
+                    // 2. Fans (Label Match)
+                    if file_name.starts_with("fan") && file_name.ends_with("_label") {
+                        if let Some(label) = read_sysfs_with_timeout(&hw_entry.path(), Duration::from_millis(500)) {
+                            if cfg.fan_labels.iter().any(|l| label.contains(l)) {
+                                let input_path = hwmon_path.join(file_name.replace("_label", "_input"));
+                                if input_path.exists() {
+                                    debug!("Discovered fan by label: {:?} (priority {})", input_path, priority);
+                                    fan_candidates.push((priority, input_path));
+                                }
                             }
                         }
                     }
+
+                    // 3. Fans (Priority Fallback - CRITICAL FOR DELL 9380)
+                    // If we found a priority driver (e.g., dell_smm), we take every fan*_input we find.
+                    if priority < usize::MAX && file_name.starts_with("fan") && file_name.ends_with("_input") {
+                        if !fan_candidates.iter().any(|(_, p)| p == &hw_entry.path()) {
+                            info!("Heuristic Discovery: Force-adding unlabeled fan sensor from priority driver '{}': {:?}", driver_name, hw_entry.path());
+                            fan_candidates.push((priority, hw_entry.path()));
+                        }
+                    }
                 }
             }
         }
@@ -171,45 +181,45 @@ fn discover_hwmon(base_path: &Path, cfg: &SensorDiscovery) -> (Option<PathBuf>,
     fan_candidates.sort_by_key(|(p, _)| *p);
 
     let best_temp = temp_candidates.first().map(|(_, p)| p.clone());
-    let best_fans = fan_candidates.into_iter().map(|(_, p)| p).collect();
+    let best_fans: Vec<PathBuf> = fan_candidates.into_iter().map(|(_, p)| p).collect();
+
+    if best_fans.is_empty() {
+        warn!("Heuristic Discovery: No fan RPM sensors found.");
+    } else {
+        info!("Heuristic Discovery: Final registry contains {} fan sensors.", best_fans.len());
+    }
 
     (best_temp, best_fans)
 }
 
-/// Discovers RAPL powercap paths.
 fn discover_rapl(base_path: &Path, cfg: &ActuatorDiscovery) -> Vec<PathBuf> {
     let mut paths = Vec::new();
     let powercap_base = base_path.join("sys/class/powercap");
     
-    let entries = match fs::read_dir(&powercap_base) {
-        Ok(e) => e,
-        Err(_) => return Vec::new(),
-    };
-
-    for entry in entries.flatten() {
-        let path = entry.path();
-        let dir_name = entry.file_name().into_string().unwrap_or_default();
-        
-        if cfg.rapl_paths.contains(&dir_name) {
-            paths.push(path);
-            continue;
-        }
-
-        if let Some(name) = read_sysfs_with_timeout(&path.join("name"), Duration::from_millis(100)) {
-            if cfg.rapl_paths.iter().any(|p| p == &name) {
+    if let Ok(entries) = fs::read_dir(&powercap_base) {
+        for entry in entries.flatten() {
+            let path = entry.path();
+            let dir_name = entry.file_name().into_string().unwrap_or_default();
+            
+            if cfg.rapl_paths.contains(&dir_name) {
                 paths.push(path);
+                continue;
+            }
+
+            if let Ok(name) = fs::read_to_string(path.join("name")) {
+                if cfg.rapl_paths.iter().any(|p| p == name.trim()) {
+                    paths.push(path);
+                }
             }
         }
     }
     paths
 }
 
-/// Checks if a systemd service is currently active using the injected runner.
 pub fn is_service_active(runner: &dyn SyscallRunner, service: &str) -> bool {
     runner.run("systemctl", &["is-active", "--quiet", service]).is_ok()
 }
 
-/// Helper to read a sysfs file with a timeout.
 fn read_sysfs_with_timeout(path: &Path, timeout: Duration) -> Option<String> {
     let (tx, rx) = mpsc::channel();
     let path_buf = path.to_path_buf();