use crate::core::{
cpu::{CpuCore, CpuFrequency, CpuStats, CpuTotal},
gpu::GpuStats,
memory::{MemoryStats, RamInfo, SwapInfo},
platform_info::{BoardInfo, HardwareInfo, LibraryVersions, PlatformInfo},
power::PowerStats,
temperature::TemperatureStats,
};
use crate::error::{IronError, Result};
use std::collections::HashMap;
use std::mem;
use std::sync::{Mutex, PoisonError};
use std::time::Duration;
use windows::Win32::System::ProcessStatus::{GetPerformanceInfo, PERFORMANCE_INFORMATION};
use windows::Win32::System::SystemInformation::{
GetSystemInfo, GlobalMemoryStatusEx, MEMORYSTATUSEX, SYSTEM_INFO,
};
static PREV_CPU_COUNTERS: Mutex<Option<CpuCounters>> = Mutex::new(None);
const PRIME_INTERVAL: Duration = Duration::from_millis(200);
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
struct SystemTimesSample {
idle: u64,
kernel: u64,
user: u64,
}
#[derive(Clone)]
struct CpuCounters {
system: SystemTimesSample,
cores: Option<Vec<SystemProcessorPerformanceInformation>>,
}
type Percent3 = (f32, f32, f32);
type CoreSplits = Vec<Option<Percent3>>;
#[derive(Default)]
struct CpuSplit {
system: Option<Percent3>,
cores: Option<CoreSplits>,
}
pub fn read_cpu_stats() -> Result<CpuStats> {
let mut stats = CpuStats::empty();
let mut sys_info: SYSTEM_INFO = unsafe { mem::zeroed() };
unsafe { GetSystemInfo(&mut sys_info) };
let cpu_count = sys_info.dwNumberOfProcessors as usize;
let ((user_percent, system_percent, idle_percent), per_core) = sample_cpu_split(cpu_count)?;
let model = get_cpu_model_name();
let power = query_processor_power(cpu_count);
let delivered = crate::platform::windows_pdh::processor_performance_percent();
for cpu_id in 0..cpu_count {
let (core_user, core_system, core_idle) = match per_core
.as_ref()
.and_then(|cores| cores.get(cpu_id))
.copied()
.flatten()
{
Some((u, s, i)) => (Some(u), Some(s), Some(i)),
None => (None, None, None),
};
let core = CpuCore {
id: cpu_id,
online: None,
governor: None,
frequency: get_cpu_frequency(power.as_ref(), cpu_id, delivered.as_ref()),
user: core_user,
nice: None,
system: core_system,
idle: core_idle,
model: model.clone(),
};
stats.cores.push(core);
}
stats.total = CpuTotal {
user: user_percent,
nice: None,
system: system_percent,
idle: idle_percent,
};
Ok(stats)
}
#[repr(C)]
#[derive(Clone, Copy, Default)]
struct SystemProcessorPerformanceInformation {
idle_time: i64,
kernel_time: i64,
user_time: i64,
dpc_time: i64,
interrupt_time: i64,
interrupt_count: u32,
_reserved: u32,
}
const SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION_CLASS: u32 = 8;
#[link(name = "ntdll")]
extern "system" {
fn NtQuerySystemInformation(
system_information_class: u32,
system_information: *mut core::ffi::c_void,
system_information_length: u32,
return_length: *mut u32,
) -> i32;
}
fn query_per_core_times(cpu_count: usize) -> Option<Vec<SystemProcessorPerformanceInformation>> {
if cpu_count == 0 {
return None;
}
let mut buffer: Vec<SystemProcessorPerformanceInformation> =
vec![SystemProcessorPerformanceInformation::default(); cpu_count];
let byte_len = std::mem::size_of_val(buffer.as_slice()) as u32;
let mut returned: u32 = 0;
let status = unsafe {
NtQuerySystemInformation(
SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION_CLASS,
buffer.as_mut_ptr() as *mut core::ffi::c_void,
byte_len,
&mut returned,
)
};
if status < 0 {
return None;
}
let record_size = std::mem::size_of::<SystemProcessorPerformanceInformation>();
let returned_records = (returned as usize) / record_size;
if returned_records == 0 {
return None;
}
buffer.truncate(returned_records.min(cpu_count));
Some(buffer)
}
#[repr(C)]
struct SystemProcessInformation {
next_entry_offset: u32,
number_of_threads: u32,
reserved1: [u8; 48],
image_name_length: u16,
image_name_maximum_length: u16,
image_name_buffer: *mut u16,
base_priority: i32,
unique_process_id: usize,
reserved2: *mut core::ffi::c_void,
handle_count: u32,
session_id: u32,
reserved3: *mut core::ffi::c_void,
peak_virtual_size: usize,
virtual_size: usize,
reserved4: u32,
peak_working_set_size: usize,
working_set_size: usize,
reserved5: *mut core::ffi::c_void,
quota_paged_pool_usage: usize,
reserved6: *mut core::ffi::c_void,
quota_non_paged_pool_usage: usize,
pagefile_usage: usize,
peak_pagefile_usage: usize,
private_page_count: usize,
reserved7: [i64; 6],
}
const SYSTEM_PROCESS_INFORMATION_CLASS: u32 = 5;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct ProcessTableEntry {
pub working_set_bytes: u64,
pub pagefile_usage_bytes: u64,
pub private_bytes: u64,
pub handle_count: u32,
pub thread_count: u32,
pub create_time_100ns: u64,
pub user_time_100ns: u64,
pub kernel_time_100ns: u64,
pub io_read_bytes: u64,
pub io_write_bytes: u64,
}
pub(crate) fn system_process_table() -> Option<std::collections::HashMap<u32, ProcessTableEntry>> {
let mut size: u32 = 1 << 20;
let mut buffer: Vec<u64>;
loop {
buffer = vec![0u64; (size as usize).div_ceil(8)];
let mut returned: u32 = 0;
let status = unsafe {
NtQuerySystemInformation(
SYSTEM_PROCESS_INFORMATION_CLASS,
buffer.as_mut_ptr() as *mut core::ffi::c_void,
size,
&mut returned,
)
};
const STATUS_INFO_LENGTH_MISMATCH: i32 = 0xC000_0004_u32 as i32;
if status == STATUS_INFO_LENGTH_MISMATCH && size < (64 << 20) {
size = returned.max(size) * 2;
continue;
}
if status < 0 {
return None;
}
break;
}
let bytes =
unsafe { std::slice::from_raw_parts(buffer.as_ptr() as *const u8, buffer.len() * 8) };
let record = std::mem::size_of::<SystemProcessInformation>();
let read_u64 = |b: &[u8], at: usize| u64::from_le_bytes(b[at..at + 8].try_into().unwrap());
let mut table = std::collections::HashMap::new();
let mut offset = 0usize;
while offset + record <= bytes.len() {
let entry = unsafe { &*(bytes.as_ptr().add(offset) as *const SystemProcessInformation) };
let pid = entry.unique_process_id as u32;
table.insert(
pid,
ProcessTableEntry {
working_set_bytes: entry.working_set_size as u64,
pagefile_usage_bytes: entry.pagefile_usage as u64,
private_bytes: entry.private_page_count as u64,
handle_count: entry.handle_count,
thread_count: entry.number_of_threads,
create_time_100ns: read_u64(&entry.reserved1, 24),
user_time_100ns: read_u64(&entry.reserved1, 32),
kernel_time_100ns: read_u64(&entry.reserved1, 40),
io_read_bytes: entry.reserved7[3] as u64,
io_write_bytes: entry.reserved7[4] as u64,
},
);
if entry.next_entry_offset == 0 {
break;
}
offset += entry.next_entry_offset as usize;
}
(!table.is_empty()).then_some(table)
}
pub(crate) fn wmi_query(
namespace: &str,
query: &str,
) -> std::result::Result<
Vec<std::collections::HashMap<String, wmi::Variant>>,
crate::error::IronError,
> {
use wmi::{COMLibrary, WMIConnection};
let com = COMLibrary::new()
.or_else(|_| COMLibrary::without_security())
.unwrap_or_else(|_| unsafe { COMLibrary::assume_initialized() });
let conn = WMIConnection::with_namespace_path(namespace, com)
.map_err(|e| crate::error::IronError::System(format!("WMI {namespace}: {e}")))?;
conn.raw_query(query)
.map_err(|e| crate::error::IronError::System(format!("WMI query `{query}`: {e}")))
}
pub(crate) fn wmi_str<'a>(
row: &'a std::collections::HashMap<String, wmi::Variant>,
key: &str,
) -> &'a str {
match row.get(key) {
Some(wmi::Variant::String(s)) => s.as_str(),
_ => "",
}
}
pub(crate) fn is_elevated() -> Option<bool> {
use windows::Win32::Foundation::{CloseHandle, HANDLE};
use windows::Win32::Security::{
GetTokenInformation, TokenElevation, TOKEN_ELEVATION, TOKEN_QUERY,
};
use windows::Win32::System::Threading::{GetCurrentProcess, OpenProcessToken};
let mut token = HANDLE::default();
unsafe { OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &mut token) }.ok()?;
let mut elevation = TOKEN_ELEVATION::default();
let mut returned = 0u32;
let read = unsafe {
GetTokenInformation(
token,
TokenElevation,
Some(std::ptr::addr_of_mut!(elevation) as *mut core::ffi::c_void),
std::mem::size_of::<TOKEN_ELEVATION>() as u32,
&mut returned,
)
};
let _ = unsafe { CloseHandle(token) };
read.ok()?;
Some(elevation.TokenIsElevated != 0)
}
fn sample_cpu_split(cpu_count: usize) -> Result<(Percent3, Option<CoreSplits>)> {
let now = read_cpu_counters(cpu_count)?;
let mut split = match replace_previous_counters(now.clone()) {
Some(before) => counter_split(&before, &now),
None => CpuSplit::default(),
};
let mut earlier = now;
for _ in 0..2 {
if split.system.is_some() {
break;
}
std::thread::sleep(PRIME_INTERVAL);
let later = read_cpu_counters(cpu_count)?;
replace_previous_counters(later.clone());
split = counter_split(&earlier, &later);
earlier = later;
}
match split.system {
Some(system) => Ok((system, split.cores)),
None => Err(IronError::Parse(
"GetSystemTimes reported no CPU time over the sampling interval".to_string(),
)),
}
}
fn read_cpu_counters(cpu_count: usize) -> Result<CpuCounters> {
Ok(CpuCounters {
system: read_system_times()?,
cores: query_per_core_times(cpu_count),
})
}
fn counter_split(before: &CpuCounters, now: &CpuCounters) -> CpuSplit {
CpuSplit {
system: split_system_times(before.system, now.system),
cores: match (&before.cores, &now.cores) {
(Some(before), Some(now)) => split_processor_times(before, now),
_ => None,
},
}
}
fn read_system_times() -> Result<SystemTimesSample> {
use windows::Win32::Foundation::FILETIME;
#[link(name = "kernel32")]
extern "system" {
fn GetSystemTimes(
lpIdleTime: *mut FILETIME,
lpKernelTime: *mut FILETIME,
lpUserTime: *mut FILETIME,
) -> i32;
}
let mut idle_time: FILETIME = unsafe { mem::zeroed() };
let mut kernel_time: FILETIME = unsafe { mem::zeroed() };
let mut user_time: FILETIME = unsafe { mem::zeroed() };
let result = unsafe { GetSystemTimes(&mut idle_time, &mut kernel_time, &mut user_time) };
if result == 0 {
return Err(IronError::System("GetSystemTimes failed".to_string()));
}
Ok(SystemTimesSample {
idle: filetime_to_u64(&idle_time),
kernel: filetime_to_u64(&kernel_time),
user: filetime_to_u64(&user_time),
})
}
fn replace_previous_counters(now: CpuCounters) -> Option<CpuCounters> {
let mut previous = PREV_CPU_COUNTERS
.lock()
.unwrap_or_else(PoisonError::into_inner);
previous.replace(now)
}
fn split_system_times(
before: SystemTimesSample,
now: SystemTimesSample,
) -> Option<(f32, f32, f32)> {
let idle = now.idle.checked_sub(before.idle)?;
let kernel = now.kernel.checked_sub(before.kernel)?;
let user = now.user.checked_sub(before.user)?;
percentages(user, kernel, idle)
}
fn split_processor_times(
before: &[SystemProcessorPerformanceInformation],
now: &[SystemProcessorPerformanceInformation],
) -> Option<Vec<Option<(f32, f32, f32)>>> {
if before.len() != now.len() {
return None;
}
let delta = |now: i64, before: i64| u64::try_from(now.checked_sub(before)?).ok();
Some(
before
.iter()
.zip(now)
.map(|(before, now)| {
percentages(
delta(now.user_time, before.user_time)?,
delta(now.kernel_time, before.kernel_time)?,
delta(now.idle_time, before.idle_time)?,
)
})
.collect(),
)
}
fn percentages(user: u64, kernel: u64, idle: u64) -> Option<(f32, f32, f32)> {
let system = kernel.checked_sub(idle)?;
let total = idle.checked_add(system)?.checked_add(user)?;
if total == 0 {
return None;
}
let basis = total as f64;
let percent = |ticks: u64| (ticks as f64 / basis * 100.0) as f32;
Some((percent(user), percent(system), percent(idle)))
}
fn filetime_to_u64(ft: &windows::Win32::Foundation::FILETIME) -> u64 {
((ft.dwHighDateTime as u64) << 32) | (ft.dwLowDateTime as u64)
}
#[repr(C)]
#[derive(Clone, Copy, Default)]
struct ProcessorPowerInformation {
number: u32,
max_mhz: u32,
current_mhz: u32,
mhz_limit: u32,
max_idle_state: u32,
current_idle_state: u32,
}
const PROCESSOR_INFORMATION_LEVEL: i32 = 11;
fn query_processor_power(cpu_count: usize) -> Option<Vec<ProcessorPowerInformation>> {
use windows::Win32::System::Power::CallNtPowerInformation;
if cpu_count == 0 {
return None;
}
let mut buffer: Vec<ProcessorPowerInformation> =
vec![ProcessorPowerInformation::default(); cpu_count];
let bytes = std::mem::size_of_val(buffer.as_slice()) as u32;
let status = unsafe {
CallNtPowerInformation(
windows::Win32::System::Power::POWER_INFORMATION_LEVEL(PROCESSOR_INFORMATION_LEVEL),
None,
0,
Some(buffer.as_mut_ptr() as *mut core::ffi::c_void),
bytes,
)
};
status.ok().ok().map(|_| buffer)
}
fn get_cpu_frequency(
power: Option<&Vec<ProcessorPowerInformation>>,
index: usize,
delivered: Option<&Vec<Option<f64>>>,
) -> Option<CpuFrequency> {
let entry = power?.get(index)?;
if entry.current_mhz == 0 && entry.max_mhz == 0 {
return None;
}
let derived = delivered
.and_then(|d| d.get(index).copied().flatten())
.filter(|pct| *pct > 0.0)
.map(|pct| (f64::from(entry.max_mhz) * pct / 100.0).round() as u32);
let measured = (entry.current_mhz != entry.max_mhz).then_some(entry.current_mhz);
let current_is_derived = measured.is_none() && derived.is_some();
Some(CpuFrequency {
current_is_derived,
current: measured.or(derived),
min: None,
max: (entry.max_mhz > 0).then_some(entry.max_mhz),
})
}
fn get_cpu_model_name() -> Option<String> {
static MODEL: std::sync::OnceLock<Option<String>> = std::sync::OnceLock::new();
MODEL
.get_or_init(|| {
read_registry_string(
r"HARDWARE\DESCRIPTION\System\CentralProcessor\0",
"ProcessorNameString",
)
})
.clone()
}
pub(crate) fn read_registry_string(subkey: &str, value: &str) -> Option<String> {
use winreg::enums::HKEY_LOCAL_MACHINE;
use winreg::RegKey;
let key = RegKey::predef(HKEY_LOCAL_MACHINE)
.open_subkey(subkey)
.ok()?;
let raw: String = key.get_value(value).ok()?;
let trimmed = raw.trim();
if trimmed.is_empty() {
None
} else {
Some(trimmed.to_string())
}
}
pub(crate) fn read_registry_u32(subkey: &str, value: &str) -> Option<u32> {
use winreg::enums::HKEY_LOCAL_MACHINE;
use winreg::RegKey;
let key = RegKey::predef(HKEY_LOCAL_MACHINE)
.open_subkey(subkey)
.ok()?;
key.get_value(value).ok()
}
pub(crate) fn adapter_vram_bytes() -> Vec<(String, u64)> {
use winreg::enums::HKEY_LOCAL_MACHINE;
use winreg::RegKey;
const DISPLAY_CLASS: &str =
r"SYSTEM\CurrentControlSet\Control\Class\{4d36e968-e325-11ce-bfc1-08002be10318}";
let Ok(class_key) = RegKey::predef(HKEY_LOCAL_MACHINE).open_subkey(DISPLAY_CLASS) else {
return Vec::new();
};
let names: Vec<String> = class_key.enum_keys().flatten().collect();
names
.into_iter()
.filter_map(|name| {
let key = class_key.open_subkey(&name).ok()?;
let desc: String = key.get_value("DriverDesc").ok()?;
let bytes: u64 = key.get_value("HardwareInformation.qwMemorySize").ok()?;
(bytes > 0).then(|| (desc.trim().to_string(), bytes))
})
.collect()
}
pub(crate) fn firmware_type() -> Option<crate::boot_config::BootType> {
use windows::Win32::System::SystemInformation::{
FirmwareTypeBios, FirmwareTypeUefi, GetFirmwareType, FIRMWARE_TYPE,
};
let mut kind = FIRMWARE_TYPE::default();
unsafe { GetFirmwareType(&mut kind) }.ok()?;
if kind == FirmwareTypeUefi {
Some(crate::boot_config::BootType::Uefi)
} else if kind == FirmwareTypeBios {
Some(crate::boot_config::BootType::Legacy)
} else {
None
}
}
pub(crate) fn secure_boot_enabled() -> Option<bool> {
read_registry_u32(
r"SYSTEM\CurrentControlSet\Control\SecureBoot\State",
"UEFISecureBootEnabled",
)
.map(|v| v == 1)
}
#[cfg(target_os = "windows")]
fn read_pagefile_usage() -> Option<SwapInfo> {
use serde::Deserialize;
use wmi::{COMLibrary, WMIConnection};
#[derive(Deserialize)]
#[serde(rename_all = "PascalCase")]
struct PageFileUsage {
allocated_base_size: u32,
current_usage: u32,
}
let com = COMLibrary::new().ok()?;
let conn = WMIConnection::new(com).ok()?;
let rows: Vec<PageFileUsage> = conn
.raw_query("SELECT AllocatedBaseSize, CurrentUsage FROM Win32_PageFileUsage")
.ok()?;
let mb_to_kb = |mb: u32| u64::from(mb) * 1024;
Some(SwapInfo {
total: Some(rows.iter().map(|r| mb_to_kb(r.allocated_base_size)).sum()),
used: Some(rows.iter().map(|r| mb_to_kb(r.current_usage)).sum()),
cached: None,
})
}
pub fn read_memory_stats() -> Result<MemoryStats> {
let mut mem_status: MEMORYSTATUSEX = unsafe { mem::zeroed() };
mem_status.dwLength = mem::size_of::<MEMORYSTATUSEX>() as u32;
unsafe {
GlobalMemoryStatusEx(&mut mem_status)
.map_err(|e| IronError::System(format!("GlobalMemoryStatusEx failed: {}", e)))?;
}
let swap_info = read_pagefile_usage().unwrap_or(SwapInfo {
total: None,
used: None,
cached: None,
});
let system_cache_kb = {
let mut perf: PERFORMANCE_INFORMATION = unsafe { mem::zeroed() };
perf.cb = mem::size_of::<PERFORMANCE_INFORMATION>() as u32;
if unsafe { GetPerformanceInfo(&mut perf, perf.cb) }.is_ok() {
Some((perf.SystemCache as u64).saturating_mul(perf.PageSize as u64) / 1024)
} else {
None
}
};
let total_kb = mem_status.ullTotalPhys / 1024;
let avail_kb = mem_status.ullAvailPhys / 1024;
let used_kb = total_kb - avail_kb;
Ok(MemoryStats {
ram: RamInfo {
total: total_kb,
used: used_kb,
free: crate::platform::windows_pdh::free_and_zero_page_list_bytes()
.map(|bytes| bytes / 1024),
buffers: None,
cached: system_cache_kb,
shared: None,
lfb: None,
},
swap: swap_info,
emc: None, iram: None, })
}
pub fn get_system_uptime() -> std::time::Duration {
use windows::Win32::System::SystemInformation::GetTickCount64;
let ticks = unsafe { GetTickCount64() };
std::time::Duration::from_millis(ticks)
}
static GPU_COLLECTION: std::sync::OnceLock<std::sync::Mutex<crate::gpu::GpuCollection>> =
std::sync::OnceLock::new();
pub fn read_gpu_stats() -> Result<GpuStats> {
use crate::core::gpu::{GpuFrequency, GpuInfo, GpuStatus, GpuType};
let mut stats = GpuStats::new();
let collection = GPU_COLLECTION.get_or_init(|| {
std::sync::Mutex::new(crate::gpu::GpuCollection::auto_detect().unwrap_or_default())
});
let collection = collection
.lock()
.map_err(|_| IronError::HardwareError("GPU collection mutex poisoned".to_string()))?;
let snapshots = collection.snapshot_all_partial();
let gpus = stats.gpus_mut();
for info in snapshots.into_iter().flatten() {
let si = &info.static_info;
let di = &info.dynamic_info;
let status = GpuStatus {
load: di.utilization.map(f32::from),
railgate: None,
tpc_pg_mask: None,
scaling_3d: None,
memory_used: di.memory.used,
memory_total: di.memory.total,
memory_free: di.memory.free,
temperature: di.thermal.temperature.map(|t| t as f32),
power_draw: di.power.draw.map(|mw| mw as f32 / 1000.0),
power_limit: di.power.limit.map(|mw| mw as f32 / 1000.0),
};
let frequency = GpuFrequency {
current: di.clocks.graphics.or(di.clocks.sm),
min: None,
max: di.clocks.graphics_max,
governor: None,
gpc: None,
};
let gpu = GpuInfo {
gpu_type: match si.integrated {
Some(true) => GpuType::Integrated,
Some(false) => GpuType::Discrete,
None => GpuType::Unknown,
},
status,
frequency,
power_control: None,
};
let key = if gpus.contains_key(&si.name) {
format!("{} #{}", si.name, si.index)
} else {
si.name.clone()
};
gpus.insert(key, gpu);
}
Ok(stats)
}
pub fn read_power_stats() -> Result<PowerStats> {
use serde::Deserialize;
use wmi::{COMLibrary, WMIConnection};
#[derive(Deserialize, Debug)]
#[serde(rename_all = "PascalCase")]
struct BatteryStatus {
instance_name: Option<String>,
voltage: Option<u32>,
discharge_rate: Option<u32>,
charge_rate: Option<u32>,
discharging: Option<bool>,
}
let mut power_stats = PowerStats::default();
let Ok(com_con) = COMLibrary::new() else {
return Ok(power_stats);
};
let Ok(wmi_con) = WMIConnection::with_namespace_path("root\\WMI", com_con) else {
return Ok(power_stats);
};
let batteries: Vec<BatteryStatus> = wmi_con
.raw_query(
"SELECT InstanceName, Voltage, DischargeRate, ChargeRate, Discharging \
FROM BatteryStatus",
)
.unwrap_or_default();
for (idx, battery) in batteries.iter().enumerate() {
let (rate_mw, sensor_type) = match (battery.discharge_rate, battery.charge_rate) {
(Some(d), _) if d > 0 => (d, "Battery (discharging)"),
(_, Some(c)) if c > 0 => (c, "Battery (charging)"),
(Some(_), _) | (_, Some(_)) => (
0,
match battery.discharging {
Some(true) => "Battery (discharging)",
Some(false) => "Battery (idle)",
None => "Battery",
},
),
(None, None) => continue,
};
let name = battery
.instance_name
.clone()
.unwrap_or_else(|| format!("Battery{}", idx));
power_stats.rails.insert(
name,
crate::core::power::PowerRail {
online: true,
sensor_type: sensor_type.to_string(),
voltage: battery.voltage,
current: None,
power: Some(rate_mw),
average: None,
warn: None,
crit: None,
},
);
power_stats.total.power = Some(power_stats.total.power.unwrap_or(0) + rate_mw);
}
Ok(power_stats)
}
pub fn read_temperature_stats() -> Result<TemperatureStats> {
use serde::Deserialize;
use std::collections::HashMap;
use wmi::{COMLibrary, WMIConnection};
#[derive(Deserialize, Debug)]
#[serde(rename_all = "PascalCase")]
struct ThermalZone {
instance_name: String,
current_temperature: u32, critical_trip_point: Option<u32>,
}
#[derive(Deserialize, Debug)]
#[serde(rename_all = "PascalCase")]
struct PerfThermalZone {
name: String,
temperature: u32, }
#[derive(Deserialize, Debug)]
#[serde(rename_all = "PascalCase")]
#[allow(dead_code)]
struct OhmSensor {
name: String,
sensor_type: String,
value: f32,
parent: String,
}
let mut sensors = HashMap::new();
let com_con = COMLibrary::new()
.map_err(|e| IronError::System(format!("Failed to initialize COM: {}", e)))?;
if let Ok(ohm_con) = WMIConnection::with_namespace_path("root\\OpenHardwareMonitor", com_con) {
let ohm_sensors: Vec<OhmSensor> = ohm_con
.raw_query("SELECT Name, SensorType, Value, Parent FROM Sensor WHERE SensorType = 'Temperature'")
.unwrap_or_default();
for sensor in ohm_sensors {
let sensor_name = if sensor.parent.contains("CPU") || sensor.name.contains("CPU") {
format!("CPU-{}", sensor.name.replace(' ', "_"))
} else if sensor.parent.contains("Motherboard") {
format!("MB-{}", sensor.name.replace(' ', "_"))
} else {
continue; };
sensors.insert(
sensor_name,
crate::core::temperature::TemperatureSensor {
online: true,
temp: sensor.value,
max: None,
crit: None,
},
);
}
}
if let Ok(lhm_con) = WMIConnection::with_namespace_path("root\\LibreHardwareMonitor", com_con) {
let lhm_sensors: Vec<OhmSensor> = lhm_con
.raw_query("SELECT Name, SensorType, Value, Parent FROM Sensor WHERE SensorType = 'Temperature'")
.unwrap_or_default();
for sensor in lhm_sensors {
let sensor_name = if sensor.parent.contains("CPU") || sensor.name.contains("CPU") {
format!("CPU-{}", sensor.name.replace(' ', "_"))
} else if sensor.parent.contains("Motherboard") {
format!("MB-{}", sensor.name.replace(' ', "_"))
} else {
continue;
};
if let std::collections::hash_map::Entry::Vacant(e) = sensors.entry(sensor_name) {
e.insert(crate::core::temperature::TemperatureSensor {
online: true,
temp: sensor.value,
max: None,
crit: None,
});
}
}
}
if let Ok(cimv2_con) = WMIConnection::with_namespace_path("root\\CIMV2", com_con) {
let perf_zones: Vec<PerfThermalZone> = cimv2_con
.raw_query("SELECT Name, Temperature FROM Win32_PerfFormattedData_Counters_ThermalZoneInformation")
.unwrap_or_default();
for zone in perf_zones {
let temp_celsius = zone.temperature as f32 - 273.15;
if temp_celsius > 0.0 && temp_celsius < 150.0 {
let sensor_name = format!("TZ-{}", zone.name.replace("\\_TZ.", ""));
sensors
.entry(sensor_name)
.or_insert(crate::core::temperature::TemperatureSensor {
online: true,
temp: temp_celsius,
max: None,
crit: None,
});
}
}
}
if let Ok(wmi_con) = WMIConnection::with_namespace_path("root\\WMI", com_con) {
let thermal_zones: Vec<ThermalZone> = wmi_con
.raw_query(
"SELECT InstanceName, CurrentTemperature, CriticalTripPoint \
FROM MSAcpi_ThermalZoneTemperature",
)
.unwrap_or_default();
for zone in thermal_zones {
let temp_celsius = (zone.current_temperature as f32 / 10.0) - 273.15;
if temp_celsius > 0.0 && temp_celsius < 150.0 {
let sensor_name = zone
.instance_name
.replace("ACPI\\ThermalZone\\", "")
.replace("_0", "");
if !sensors.contains_key(&format!("TZ-{}", sensor_name)) {
sensors.insert(
format!("ACPI-{}", sensor_name),
crate::core::temperature::TemperatureSensor {
online: true,
temp: temp_celsius,
max: None,
crit: zone
.critical_trip_point
.filter(|&t| t > 0)
.map(|t| t as f32 / 10.0 - 273.15),
},
);
}
}
}
}
Ok(TemperatureStats { sensors })
}
pub fn detect_platform() -> Result<BoardInfo> {
const BIOS_KEY: &str = r"HARDWARE\DESCRIPTION\System\BIOS";
let manufacturer = read_registry_string(BIOS_KEY, "BaseBoardManufacturer");
let model = read_registry_string(BIOS_KEY, "BaseBoardProduct");
const CURRENT_VERSION: &str = r"SOFTWARE\Microsoft\Windows NT\CurrentVersion";
let build = read_registry_string(CURRENT_VERSION, "CurrentBuildNumber");
let release = match (&build, read_registry_u32(CURRENT_VERSION, "UBR")) {
(Some(build), Some(ubr)) => format!("{build}.{ubr}"),
(Some(build), None) => build.clone(),
(None, _) => String::new(),
};
let distribution = read_registry_string(CURRENT_VERSION, "ProductName").map(|product| {
let build: u32 = build.as_deref().and_then(|b| b.parse().ok()).unwrap_or(0);
if build >= 22000 {
product.replace("Windows 10", "Windows 11")
} else {
product
}
});
Ok(BoardInfo {
platform: PlatformInfo {
machine: std::env::consts::ARCH.to_string(),
system: "Windows".to_string(),
distribution,
release,
},
hardware: HardwareInfo {
model: model.unwrap_or_default(),
p_number: None,
module: manufacturer,
soc: None,
cuda_arch: None,
codename: None,
serial_number: None,
l4t: None,
jetpack: None,
},
libraries: LibraryVersions {
cuda: None,
cudnn: None,
tensorrt: None,
other: HashMap::new(),
},
})
}
pub fn read_process_stats() -> Result<crate::core::process::ProcessStats> {
use crate::core::process::{ProcessInfo, ProcessStats};
use std::mem;
use windows::Win32::Foundation::CloseHandle;
use windows::Win32::System::Diagnostics::ToolHelp::{
CreateToolhelp32Snapshot, Process32FirstW, Process32NextW, PROCESSENTRY32W,
TH32CS_SNAPPROCESS,
};
use windows::Win32::System::ProcessStatus::{GetProcessMemoryInfo, PROCESS_MEMORY_COUNTERS};
use windows::Win32::System::Threading::{
OpenProcess, PROCESS_QUERY_INFORMATION, PROCESS_VM_READ,
};
let mut stats = ProcessStats::empty();
unsafe {
let snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)
.map_err(|e| IronError::System(format!("Failed to create process snapshot: {}", e)))?;
let mut entry: PROCESSENTRY32W = mem::zeroed();
entry.dwSize = mem::size_of::<PROCESSENTRY32W>() as u32;
if Process32FirstW(snapshot, &mut entry).is_ok() {
loop {
let pid = entry.th32ProcessID;
let name_len = entry
.szExeFile
.iter()
.position(|&c| c == 0)
.unwrap_or(entry.szExeFile.len());
let name = String::from_utf16_lossy(&entry.szExeFile[..name_len]);
let mut memory_kb = 0u64;
if let Ok(process_handle) =
OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, pid)
{
let mut mem_counters: PROCESS_MEMORY_COUNTERS = mem::zeroed();
mem_counters.cb = mem::size_of::<PROCESS_MEMORY_COUNTERS>() as u32;
if GetProcessMemoryInfo(
process_handle,
&mut mem_counters,
mem::size_of::<PROCESS_MEMORY_COUNTERS>() as u32,
)
.is_ok()
{
memory_kb = mem_counters.WorkingSetSize as u64 / 1024;
}
let _ = CloseHandle(process_handle);
}
let cpu_percent: Option<f32> = None;
let state = None;
if memory_kb > 1024 {
stats.processes.push(ProcessInfo {
pid,
user: String::new(), gpu: String::new(),
process_type: None,
priority: entry.pcPriClassBase as i32,
state,
cpu_percent,
memory_kb,
gpu_memory_kb: None,
name,
});
}
if Process32NextW(snapshot, &mut entry).is_err() {
break;
}
}
}
let _ = CloseHandle(snapshot);
}
stats
.processes
.sort_by_key(|p| std::cmp::Reverse(p.memory_kb));
stats.processes.truncate(50);
Ok(stats)
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct LogicalDrive {
pub name: String,
pub total: u64,
pub used: u64,
pub free: u64,
pub filesystem: String,
}
pub fn logical_drives() -> Result<Vec<LogicalDrive>> {
use windows::core::PCWSTR;
use windows::Win32::Storage::FileSystem::{
GetDiskFreeSpaceExW, GetDriveTypeW, GetLogicalDrives, GetVolumeInformationW,
};
const DRIVE_REMOTE: u32 = 4;
const DRIVE_CDROM: u32 = 5;
let mask = unsafe { GetLogicalDrives() };
if mask == 0 {
return Err(IronError::Other(
"GetLogicalDrives returned no drives".to_string(),
));
}
let mut drives = Vec::new();
for bit in 0..26u32 {
if mask & (1 << bit) == 0 {
continue;
}
let letter = b'A' + bit as u8;
let root_wide: [u16; 4] = [letter as u16, b':' as u16, b'\\' as u16, 0];
let root = PCWSTR(root_wide.as_ptr());
let drive_type = unsafe { GetDriveTypeW(root) };
if drive_type == DRIVE_REMOTE || drive_type == DRIVE_CDROM {
continue;
}
let mut free_to_caller: u64 = 0;
let mut total: u64 = 0;
let mut total_free: u64 = 0;
let has_space = unsafe {
GetDiskFreeSpaceExW(
root,
Some(&mut free_to_caller),
Some(&mut total),
Some(&mut total_free),
)
.is_ok()
};
if !has_space || total == 0 {
continue;
}
let mut fs_buf = [0u16; 32];
let filesystem = unsafe {
if GetVolumeInformationW(root, None, None, None, None, Some(&mut fs_buf)).is_ok() {
let len = fs_buf.iter().position(|&c| c == 0).unwrap_or(fs_buf.len());
String::from_utf16_lossy(&fs_buf[..len])
} else {
"Unknown".to_string()
}
};
drives.push(LogicalDrive {
name: format!("{}:\\", letter as char),
total,
used: total.saturating_sub(total_free),
free: free_to_caller,
filesystem,
});
}
Ok(drives)
}
#[cfg(test)]
mod tests {
fn system_sample(idle: u64, kernel: u64, user: u64) -> super::SystemTimesSample {
super::SystemTimesSample { idle, kernel, user }
}
#[test]
fn system_times_split_is_the_interval_between_two_readings() {
let before = system_sample(900_000_000_000, 960_000_000_000, 40_000_000_000);
let now = system_sample(
before.idle + 30_000_000, before.kernel + 35_000_000, before.user + 5_000_000,
);
let (user, system, idle) = super::split_system_times(before, now).expect("split");
assert!((user - 12.5).abs() < 0.01, "user {user}");
assert!((system - 12.5).abs() < 0.01, "system {system}");
assert!((idle - 75.0).abs() < 0.01, "idle {idle}");
}
#[test]
fn system_times_zero_delta_is_no_reading() {
let sample = system_sample(900_000_000_000, 960_000_000_000, 40_000_000_000);
assert_eq!(super::split_system_times(sample, sample), None);
}
#[test]
fn system_times_counter_going_backwards_is_no_reading() {
let before = system_sample(900_000_000_000, 960_000_000_000, 40_000_000_000);
let now = system_sample(
before.idle - 1,
before.kernel + 35_000_000,
before.user + 5_000_000,
);
assert_eq!(super::split_system_times(before, now), None);
}
#[test]
fn system_times_kernel_below_idle_is_no_reading() {
let before = system_sample(900_000_000_000, 960_000_000_000, 40_000_000_000);
let now = system_sample(
before.idle + 30_000_000,
before.kernel + 20_000_000,
before.user + 5_000_000,
);
assert_eq!(super::split_system_times(before, now), None);
}
fn processor(
idle: i64,
kernel: i64,
user: i64,
) -> super::SystemProcessorPerformanceInformation {
super::SystemProcessorPerformanceInformation {
idle_time: idle,
kernel_time: kernel,
user_time: user,
..Default::default()
}
}
#[test]
fn processor_times_split_is_the_interval_between_two_readings() {
let before = processor(500_000_000, 600_000_000, 100_000_000);
let now = processor(
before.idle_time + 7_500_000,
before.kernel_time + 8_000_000,
before.user_time + 2_000_000,
);
let splits = super::split_processor_times(&[before], &[now]).expect("split");
let (user, system, idle) = splits[0].expect("a core that moved has a split");
assert!((user - 20.0).abs() < 0.01, "user {user}");
assert!((system - 5.0).abs() < 0.01, "system {system}");
assert!((idle - 75.0).abs() < 0.01, "idle {idle}");
}
#[test]
fn processor_with_no_movement_is_no_reading_for_that_core_only() {
let still = processor(500_000_000, 600_000_000, 100_000_000);
let moved_before = processor(400_000_000, 300_000_000, 50_000_000);
let moved_now = processor(
moved_before.idle_time + 5_000_000,
moved_before.kernel_time + 5_000_000,
moved_before.user_time + 5_000_000,
);
let splits = super::split_processor_times(&[still, moved_before], &[still, moved_now])
.expect("split");
assert_eq!(splits[0], None);
let (user, system, idle) = splits[1].expect("core 1 moved");
assert!((user - 50.0).abs() < 0.01, "user {user}");
assert!(system.abs() < 0.01, "system {system}");
assert!((idle - 50.0).abs() < 0.01, "idle {idle}");
}
#[test]
fn processor_counter_going_backwards_is_no_reading() {
let before = processor(500_000_000, 600_000_000, 100_000_000);
let now = processor(
before.idle_time - 1,
before.kernel_time + 8_000_000,
before.user_time,
);
let splits = super::split_processor_times(&[before], &[now]).expect("split");
assert_eq!(splits[0], None);
}
#[test]
fn processor_counts_that_differ_give_no_per_core_split() {
let one = processor(500_000_000, 600_000_000, 100_000_000);
assert_eq!(super::split_processor_times(&[one], &[one, one]), None);
}
#[test]
fn percentages_of_no_elapsed_ticks_is_no_reading() {
assert_eq!(super::percentages(0, 0, 0), None);
}
#[test]
fn the_process_table_agrees_with_the_handle_based_calls() {
use windows::Win32::Foundation::FILETIME;
use windows::Win32::System::ProcessStatus::{
GetProcessMemoryInfo, PROCESS_MEMORY_COUNTERS_EX,
};
use windows::Win32::System::Threading::{GetCurrentProcess, GetProcessTimes};
let mut x = 0u64;
for i in 0..20_000_000u64 {
x = x.wrapping_add(i * i);
}
std::hint::black_box(x);
let pid = std::process::id();
let (mut c, mut e, mut k, mut u) = (
FILETIME::default(),
FILETIME::default(),
FILETIME::default(),
FILETIME::default(),
);
let mut mem = PROCESS_MEMORY_COUNTERS_EX::default();
let table = super::system_process_table().expect("process table");
unsafe {
GetProcessTimes(GetCurrentProcess(), &mut c, &mut e, &mut k, &mut u).unwrap();
GetProcessMemoryInfo(
GetCurrentProcess(),
std::ptr::addr_of_mut!(mem) as *mut _,
std::mem::size_of::<PROCESS_MEMORY_COUNTERS_EX>() as u32,
)
.unwrap();
}
let ft = |f: FILETIME| (f.dwHighDateTime as u64) << 32 | f.dwLowDateTime as u64;
let row = table.get(&pid).expect("this process is in the table");
assert_eq!(row.create_time_100ns, ft(c), "create time offset");
let near = |a: u64, b: u64| a.abs_diff(b) <= 2_000_000; assert!(
near(row.user_time_100ns, ft(u)),
"user {} vs {}",
row.user_time_100ns,
ft(u)
);
assert!(
near(row.kernel_time_100ns, ft(k)),
"kernel {} vs {}",
row.kernel_time_100ns,
ft(k)
);
assert!(row.user_time_100ns > 0, "user time read as zero");
let ws = mem.WorkingSetSize as u64;
assert!(
row.working_set_bytes.abs_diff(ws) < 16 << 20,
"working set {} vs {}",
row.working_set_bytes,
ws
);
assert!(row.working_set_bytes > 0);
assert!(
table.len() > 50,
"only {} processes in the table",
table.len()
);
let manifest = std::fs::read(concat!(env!("CARGO_MANIFEST_DIR"), "/Cargo.toml"))
.expect("read Cargo.toml");
assert!(!manifest.is_empty());
let mut io = windows::Win32::System::Threading::IO_COUNTERS::default();
unsafe {
windows::Win32::System::Threading::GetProcessIoCounters(GetCurrentProcess(), &mut io)
.unwrap();
}
let row = super::system_process_table().unwrap()[&pid];
assert!(
row.io_read_bytes.abs_diff(io.ReadTransferCount) < 1 << 20,
"read {} vs {}",
row.io_read_bytes,
io.ReadTransferCount
);
assert!(row.io_read_bytes > 0, "read transfer count read as zero");
}
#[test]
fn free_memory_is_not_the_available_figure() {
let stats = super::read_memory_stats().expect("memory stats");
let available = stats.ram.total - stats.ram.used;
let free = stats
.ram
.free
.expect("the free-page counter is readable on Windows");
assert_ne!(free, available, "free is the available figure again");
assert!(
free <= available + available / 10,
"free ({free} KB) exceeds available ({available} KB)"
);
}
#[test]
fn a_nominal_clock_is_not_reported_as_the_current_one() {
let entry = |current_mhz, max_mhz| ProcessorPowerInformation {
number: 0,
max_mhz,
current_mhz,
mhz_limit: 0,
max_idle_state: 0,
current_idle_state: 0,
};
let power = vec![entry(4400, 4400)];
let f =
get_cpu_frequency(Some(&power), 0, None).expect("max is known, so a row is returned");
assert_eq!(
f.current, None,
"the nominal clock reported as current is not a reading"
);
assert_eq!(f.max, Some(4400), "the maximum is still known");
let power = vec![entry(3200, 4400)];
let f = get_cpu_frequency(Some(&power), 0, None).expect("a real reading");
assert_eq!(f.current, Some(3200));
let power = vec![entry(0, 0)];
assert!(get_cpu_frequency(Some(&power), 0, None).is_none());
}
use super::*;
#[test]
fn aggregate_cpu_agrees_with_per_core() {
let stats = read_cpu_stats().expect("cpu stats");
assert!(!stats.cores.is_empty(), "no cores reported");
let aggregate_busy = 100.0 - stats.total.idle;
let per_core: Vec<f32> = stats
.cores
.iter()
.filter_map(|c| c.idle.map(|idle| 100.0 - idle))
.collect();
if per_core.is_empty() {
eprintln!("skipping: per-core data unavailable");
return;
}
let mean_busy = per_core.iter().sum::<f32>() / per_core.len() as f32;
eprintln!("aggregate busy {aggregate_busy:.1}%, per-core mean {mean_busy:.1}%");
assert!(
!(aggregate_busy < 1.0 && mean_busy > 10.0),
"aggregate reports {aggregate_busy:.1}% busy while cores average \
{mean_busy:.1}% — the aggregate is a placeholder, not a measurement"
);
}
#[test]
fn per_core_utilization_is_not_the_system_average() {
let cpu_count = std::thread::available_parallelism()
.map(|n| n.get())
.unwrap_or(1);
let raw = query_per_core_times(cpu_count)
.expect("NtQuerySystemInformation returned no per-processor data");
assert!(!raw.is_empty(), "no per-processor records returned");
if raw.len() > 1 {
let distinct = raw
.iter()
.map(|r| r.idle_time)
.collect::<std::collections::HashSet<_>>()
.len();
eprintln!(
"{} distinct cumulative idle times across {} cores",
distinct,
raw.len()
);
assert!(
distinct > 1,
"all {} cores report identical cumulative idle time — the values are \
a single system-wide figure replicated, not per-core data",
raw.len()
);
}
let (_, cores) = sample_cpu_split(cpu_count).expect("cpu split");
let cores = cores.expect("per-core utilization");
assert!(
cores.iter().any(Option::is_some),
"first call reported no per-core figure for any core"
);
for (i, entry) in cores.iter().enumerate() {
let Some((user, system, idle)) = *entry else {
continue;
};
let total = user + system + idle;
assert!(
(total - 100.0).abs() < 1.0,
"core {i} percentages sum to {total}, expected ~100"
);
assert!(
(0.0..=100.0).contains(&idle),
"core {i} idle {idle} out of range"
);
}
}
#[test]
fn test_logical_drives() {
let drives = logical_drives().expect("enumeration should succeed");
assert!(
!drives.is_empty(),
"a Windows host always has at least one fixed drive"
);
for drive in &drives {
assert!(drive.total > 0, "{} reported zero capacity", drive.name);
assert!(
drive.used <= drive.total,
"{} used {} exceeds total {}",
drive.name,
drive.used,
drive.total
);
assert!(
drive.name.ends_with(":\\"),
"{} is not a drive root",
drive.name
);
assert!(!drive.filesystem.is_empty());
}
}
#[test]
fn test_read_cpu_stats() {
let stats = read_cpu_stats();
assert!(stats.is_ok());
let stats = stats.unwrap();
assert!(!stats.cores.is_empty());
}
#[test]
fn test_read_memory_stats() {
let stats = read_memory_stats();
assert!(stats.is_ok());
let stats = stats.unwrap();
assert!(stats.ram.total > 0);
}
#[test]
fn test_get_system_uptime() {
let uptime = get_system_uptime();
assert!(uptime.as_secs() > 0);
}
}