fix: Add Windows CPU temperature fallback chain to handle WBEM_E_NOT_FOUND (#103)

* fix: Add Windows CPU temperature fallback chain to handle WBEM_E_NOT_FOUND

Implements a cascading fallback mechanism for CPU temperature monitoring
on Windows to address the issue where MSAcpi_ThermalZoneTemperature is
not available on many systems (error 0x8004100C).

The fallback chain tries these sources in order:
1. MSAcpi_ThermalZoneTemperature (standard ACPI thermal zones)
2. AMD Ryzen Master SDK (AMD CPUs only, via FFI)
3. Intel WMI (Intel CPUs only, root/Intel namespace)
4. LibreHardwareMonitor WMI (any CPU, if app running)
5. None (graceful fallback without error spam)

Key changes:
- New module src/device/windows_temp/ with temperature sources
- TemperatureManager with OnceCell caching for availability status
- CPU vendor detection (AMD/Intel) for source selection
- Removed eprintln! calls that caused repeated error messages
- Updated documentation with Windows temperature limitations

Closes #102

* fix(security): Address security and robustness issues in Windows temperature module

Security fixes:
- Remove relative DLL path to prevent DLL hijacking attacks (CRITICAL)
- Only use absolute paths for AMD SDK DLL loading

Robustness improvements:
- Add compile-time struct size verification for RmQuickStats FFI safety
- Replace panic-on-lock-poisoning with graceful recovery pattern
- Use round() instead of truncation for temperature conversion accuracy

Code quality:
- Add Clone, Copy, PartialEq, Eq derives to TemperatureResult
- Add security and thread safety documentation to amd_ryzen.rs
- Simplify try_load_library() implementation

* fix: Resolve build warnings and improve WMI connection handling

- Add #[allow(dead_code)] to sensor_type field in libre_hwmon.rs
  (required for WMI deserialization but not used in code)
- Refactor Intel/LibreHardwareMonitor WMI sources to avoid caching
  WMIConnection (not Send + Sync), cache only namespace availability
- Fix AMD DLL path dereference in amd_ryzen.rs
- Use CpuRefreshKind::everything() for proper CPU vendor detection

* style: Apply rustfmt to intel_wmi.rs

* fix: Address cargo fmt and clippy warnings

- Use matches! macro instead of match expression in mod.rs
- Inline format arguments in eprintln! calls in amd_windows.rs

Author: inureyes

Cargo.toml

@@ -68,6 +68,7 @@ openssl = { version = "0.10.75", features = ["vendored"] }
 # Windows-specific dependencies
 [target.'cfg(target_os = "windows")'.dependencies]
 wmi = "0.18"
+libloading = "0.9"
 
 # macOS-specific dependencies
 [target.'cfg(target_os = "macos")'.dependencies]

README.md

@@ -162,6 +162,18 @@ http://gpu-node3:9090
 - **No Sudo Required:** NVIDIA GPU monitoring works without sudo privileges
 - **Driver Required:** NVIDIA proprietary drivers must be installed
 
+### Windows
+- **No Sudo Required:** GPU and CPU monitoring works without administrator privileges
+- **CPU Temperature Limitations:**
+  - Standard Windows WMI thermal zones (MSAcpi_ThermalZoneTemperature) are not available on all systems
+  - The application uses a fallback chain to try multiple temperature sources:
+    1. ACPI Thermal Zones (standard WMI)
+    2. AMD Ryzen Master SDK (AMD CPUs - requires AMD drivers or Ryzen Master)
+    3. Intel WMI (Intel CPUs - if chipset drivers support it)
+    4. LibreHardwareMonitor WMI (any CPU - if [LibreHardwareMonitor](https://github.com/LibreHardwareMonitor/LibreHardwareMonitor) is running)
+  - If temperature is not available, it will be shown as "N/A" without error messages
+  - For best temperature monitoring on Windows, install and run LibreHardwareMonitor in the background
+
 ## Features
 
 ### GPU Monitoring

docs/ARCHITECTURE.md

@@ -238,6 +238,18 @@ pub trait MetricsExporter: Send + Sync {
 - `sysctl` for runtime metrics
 - P/E-core detection for Apple Silicon
 
+#### Windows (`src/device/cpu_windows.rs`, `src/device/windows_temp/`)
+- WMI for processor information (MaxClockSpeed, cache sizes, socket count)
+- Thread-local WMI connections for efficiency
+- Temperature monitoring via fallback chain:
+  1. **MSAcpi_ThermalZoneTemperature**: Standard ACPI thermal zones (root\WMI namespace)
+  2. **AMD Ryzen Master SDK**: FFI integration with `AMDRyzenMasterMonitoringDLL.dll`
+  3. **Intel WMI**: Intel-specific thermal zones (root\Intel namespace)
+  4. **LibreHardwareMonitor**: Third-party WMI (root\LibreHardwareMonitor namespace)
+- Graceful fallback: Returns `None` silently when all sources unavailable
+- Availability caching: OnceCell/RwLock pattern to avoid repeated failed queries
+- No error spam: WBEM_E_NOT_FOUND (0x8004100C) handled silently
+
 ### Conditional Compilation
 
 ```rust

src/device/cpu_windows.rs

@@ -22,12 +22,8 @@ use std::sync::RwLock;
 use sysinfo::{CpuRefreshKind, System};
 use wmi::WMIConnection;
 
-// WMI structures for thermal zone temperature
-#[derive(Deserialize, Debug)]
-#[serde(rename_all = "PascalCase")]
-struct ThermalZoneTemperature {
-    current_temperature: Option<u32>, // Temperature in tenths of Kelvin
-}
+// Import the temperature fallback chain
+use super::windows_temp::TemperatureManager;
 
 // WMI structures for processor information
 #[derive(Deserialize, Debug)]
@@ -40,23 +36,21 @@ struct Win32Processor {
 
 // Thread-local WMI connections for reuse within the same thread
 thread_local! {
-    static WMI_CIMV2_CONNECTION: std::cell::RefCell<Option<WMIConnection>> = std::cell::RefCell::new(None);
-    static WMI_ROOT_WMI_CONNECTION: std::cell::RefCell<Option<WMIConnection>> = std::cell::RefCell::new(None);
+    static WMI_CIMV2_CONNECTION: std::cell::RefCell<Option<WMIConnection>> =
+        const { std::cell::RefCell::new(None) };
+    static WMI_ROOT_WMI_CONNECTION: std::cell::RefCell<Option<WMIConnection>> =
+        const { std::cell::RefCell::new(None) };
 }
 
 /// Helper to get or create CIMV2 connection
 fn with_cimv2_connection<T, F: FnOnce(&WMIConnection) -> T>(f: F) -> Option<T> {
     WMI_CIMV2_CONNECTION.with(|cell| {
         let mut conn_ref = cell.borrow_mut();
         if conn_ref.is_none() {
-            match WMIConnection::new() {
-                Ok(wmi_con) => {
-                    *conn_ref = Some(wmi_con);
-                }
-                Err(e) => {
-                    eprintln!("Failed to create WMI CIMV2 connection: {e}");
-                }
+            if let Ok(wmi_con) = WMIConnection::new() {
+                *conn_ref = Some(wmi_con);
             }
+            // Silently fail if connection cannot be created
         }
         conn_ref.as_ref().map(f)
     })
@@ -67,14 +61,10 @@ fn with_root_wmi_connection<T, F: FnOnce(&WMIConnection) -> T>(f: F) -> Option<T
     WMI_ROOT_WMI_CONNECTION.with(|cell| {
         let mut conn_ref = cell.borrow_mut();
         if conn_ref.is_none() {
-            match WMIConnection::with_namespace_path("root\\WMI") {
-                Ok(wmi_con) => {
-                    *conn_ref = Some(wmi_con);
-                }
-                Err(e) => {
-                    eprintln!("Failed to create WMI root\\WMI connection: {e}");
-                }
+            if let Ok(wmi_con) = WMIConnection::with_namespace_path("root\\WMI") {
+                *conn_ref = Some(wmi_con);
             }
+            // Silently fail if connection cannot be created
         }
         conn_ref.as_ref().map(f)
     })
@@ -87,6 +77,8 @@ pub struct WindowsCpuReader {
     cached_max_frequency: RwLock<Option<u32>>,
     cached_cache_size: RwLock<Option<u32>>,
     cached_socket_count: RwLock<Option<u32>>,
+    // Temperature manager with fallback chain
+    temperature_manager: TemperatureManager,
 }
 
 impl Default for WindowsCpuReader {
@@ -112,45 +104,26 @@ impl WindowsCpuReader {
             cached_max_frequency: RwLock::new(None),
             cached_cache_size: RwLock::new(None),
             cached_socket_count: RwLock::new(None),
+            temperature_manager: TemperatureManager::new(),
         }
     }
 
-    /// Get CPU temperature from WMI thermal zones (using thread-local connection)
+    /// Get CPU temperature using the fallback chain.
+    ///
+    /// Tries multiple temperature sources in order:
+    /// 1. MSAcpi_ThermalZoneTemperature (ACPI thermal zones)
+    /// 2. AMD Ryzen Master SDK (AMD CPUs only)
+    /// 3. Intel WMI (Intel CPUs only)
+    /// 4. LibreHardwareMonitor WMI (any CPU)
+    /// 5. None (graceful fallback)
     fn get_cpu_temperature(&self) -> Option<u32> {
-        with_root_wmi_connection(|wmi_con| {
-            let results: Result<Vec<ThermalZoneTemperature>, _> = wmi_con
-                .raw_query("SELECT CurrentTemperature FROM MSAcpi_ThermalZoneTemperature");
-
-            match results {
-                Ok(zones) => {
-                    if zones.is_empty() {
-                        eprintln!("CPU temperature: No thermal zones found in WMI");
-                        return None;
-                    }
-                    for zone in zones {
-                        if let Some(temp_tenths_kelvin) = zone.current_temperature {
-                            // Convert from tenths of Kelvin to Celsius
-                            // Formula: (K / 10) - 273.15 = C
-                            let celsius = (temp_tenths_kelvin as f64 / 10.0) - 273.15;
-                            if celsius > 0.0 && celsius < 150.0 {
-                                return Some(celsius as u32);
-                            } else {
-                                eprintln!(
-                                    "CPU temperature: Out of range value {:.1}°C (raw: {} tenths K)",
-                                    celsius, temp_tenths_kelvin
-                                );
-                            }
-                        }
-                    }
-                    None
-                }
-                Err(e) => {
-                    eprintln!("CPU temperature: WMI query failed: {e}");
-                    None
-                }
-            }
+        // Get the root\WMI connection for ACPI thermal zones
+        with_root_wmi_connection(|wmi_conn| {
+            self.temperature_manager.get_temperature(Some(wmi_conn))
         })
         .flatten()
+        // If root\WMI connection failed, still try other sources
+        .or_else(|| self.temperature_manager.get_temperature(None))
     }
 
     /// Get static CPU info from WMI (max frequency, cache size, socket count)
@@ -304,7 +277,7 @@ impl WindowsCpuReader {
             });
         }
 
-        // Get CPU temperature from WMI
+        // Get CPU temperature using fallback chain (no more error spam)
         let temperature = self.get_cpu_temperature();
 
         // Get static info from WMI (max frequency, cache size, socket count)
@@ -356,8 +329,8 @@ impl CpuReader for WindowsCpuReader {
     fn get_cpu_info(&self) -> Vec<CpuInfo> {
         match self.get_cpu_info_from_system() {
             Ok(cpu_info) => vec![cpu_info],
-            Err(e) => {
-                eprintln!("Error reading CPU info: {e}");
+            Err(_) => {
+                // Silently return empty - errors are expected on some systems
                 vec![]
             }
         }

src/device/mod.rs

@@ -27,6 +27,10 @@ pub mod cpu_macos;
 #[cfg(target_os = "windows")]
 pub mod cpu_windows;
 
+// Windows temperature fallback chain
+#[cfg(target_os = "windows")]
+pub mod windows_temp;
+
 // Container resource support
 #[cfg(target_os = "linux")]
 pub mod container_info;

src/device/readers/amd_windows.rs

@@ -123,16 +123,10 @@ impl AmdWindowsGpuReader {
                 // Warn if the reported VRAM is suspiciously close to 4GB limit or 0
                 const FOUR_GB: u64 = 4 * 1024 * 1024 * 1024; // 4,294,967,296 bytes
                 if total_memory == 0 {
-                    eprintln!(
-                        "AMD GPU '{}': VRAM size unavailable (reported as 0)",
-                        name
-                    );
+                    eprintln!("AMD GPU '{name}': VRAM size unavailable (reported as 0)");
                 } else if total_memory >= FOUR_GB - (512 * 1024 * 1024) {
                     // If reported value is >= 3.5GB, it might be capped/wrapped for >4GB GPU
-                    eprintln!(
-                        "AMD GPU '{}': VRAM reported as {} bytes, may be inaccurate for >4GB GPUs due to WMI 32-bit limitation",
-                        name, total_memory
-                    );
+                    eprintln!("AMD GPU '{name}': VRAM reported as {total_memory} bytes, may be inaccurate for >4GB GPUs due to WMI 32-bit limitation");
                 }
 
                 // Build detail map

src/device/windows_temp/acpi_thermal.rs

@@ -0,0 +1,99 @@
+// Copyright 2025 Lablup Inc. and Jeongkyu Shin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! ACPI Thermal Zone temperature source.
+//!
+//! Queries MSAcpi_ThermalZoneTemperature from root\WMI namespace.
+//! This is the standard Windows method but is not available on all systems.
+
+use super::{is_wmi_not_found_error, TemperatureResult};
+use serde::Deserialize;
+use wmi::WMIConnection;
+
+/// WMI structure for thermal zone temperature.
+#[derive(Deserialize, Debug)]
+#[serde(rename_all = "PascalCase")]
+struct ThermalZoneTemperature {
+    current_temperature: Option<u32>, // Temperature in tenths of Kelvin
+}
+
+/// ACPI Thermal Zone temperature source.
+pub struct AcpiThermalSource {
+    // No state needed - uses passed WMI connection
+}
+
+impl Default for AcpiThermalSource {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl AcpiThermalSource {
+    /// Create a new ACPI thermal source.
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    /// Get temperature from ACPI thermal zones.
+    ///
+    /// # Arguments
+    /// * `wmi_conn` - Optional WMI connection to root\WMI namespace
+    ///
+    /// # Returns
+    /// * `TemperatureResult::Success(temp)` - Temperature in Celsius
+    /// * `TemperatureResult::NotFound` - MSAcpi_ThermalZoneTemperature class not found
+    /// * `TemperatureResult::Error` - Transient error (connection issue, etc.)
+    /// * `TemperatureResult::NoValidReading` - Class exists but no valid temperature
+    pub fn get_temperature(&self, wmi_conn: Option<&WMIConnection>) -> TemperatureResult {
+        let conn = match wmi_conn {
+            Some(c) => c,
+            None => return TemperatureResult::Error,
+        };
+
+        let results: Result<Vec<ThermalZoneTemperature>, _> =
+            conn.raw_query("SELECT CurrentTemperature FROM MSAcpi_ThermalZoneTemperature");
+
+        match results {
+            Ok(zones) => {
+                if zones.is_empty() {
+                    // No thermal zones found - this might be a permanent condition
+                    return TemperatureResult::NoValidReading;
+                }
+
+                for zone in zones {
+                    if let Some(temp_tenths_kelvin) = zone.current_temperature {
+                        // Convert from tenths of Kelvin to Celsius
+                        // Formula: (K / 10) - 273.15 = C
+                        let celsius = (temp_tenths_kelvin as f64 / 10.0) - 273.15;
+                        if celsius > 0.0 && celsius < 150.0 {
+                            // Use round() for more accurate conversion
+                            return TemperatureResult::Success(celsius.round() as u32);
+                        }
+                        // Out of range value, continue to next zone
+                    }
+                }
+                TemperatureResult::NoValidReading
+            }
+            Err(e) => {
+                if is_wmi_not_found_error(&e) {
+                    // WBEM_E_NOT_FOUND - class doesn't exist
+                    TemperatureResult::NotFound
+                } else {
+                    // Other WMI error - likely transient
+                    TemperatureResult::Error
+                }
+            }
+        }
+    }
+}