path: root/src/data_collection/temperature/linux.rs

//! Gets temperature sensor data for Linux platforms.

use std::{
    fs,
    path::{Path, PathBuf},
};

use anyhow::Result;
use hashbrown::{HashMap, HashSet};

use super::{is_temp_filtered, TempHarvest, TemperatureReading, TemperatureType};
use crate::{app::filter::Filter, utils::error::BottomError};

const EMPTY_NAME: &str = "Unknown";

/// Returned results from grabbing hwmon/coretemp temperature sensor values/names.
struct HwmonResults {
    temperatures: Vec<TempHarvest>,
    num_hwmon: usize,
}

/// Parses and reads temperatures that were in millidegree Celsius, and if successful, returns a temperature in Celsius.
fn parse_temp(path: &Path) -> Result<f32> {
    Ok(fs::read_to_string(path)?
        .trim_end()
        .parse::<f32>()
        .map_err(|e| BottomError::ConversionError(e.to_string()))?
        / 1_000.0)
}

/// Get all candidates from hwmon and coretemp. It will also return the number of entries from hwmon.
fn get_hwmon_candidates() -> (HashSet<PathBuf>, usize) {
    let mut dirs = HashSet::default();

    if let Ok(read_dir) = Path::new("/sys/class/hwmon").read_dir() {
        for entry in read_dir.flatten() {
            let mut path = entry.path();

            // hwmon includes many sensors, we only want ones with at least one temperature sensor
            // _Reading_ this file will wake the device, but we're only checking _existence_, so
            // this shouldn't wake up the device.
            if !path.join("temp1_input").exists() {
                // Note we also check for a `device` subdirectory (e.g. `/sys/class/hwmon/hwmon*/device/`).
                // This is needed for CentOS, which adds this extra `/device` directory. See:
                // - https://github.com/nicolargo/glances/issues/1060
                // - https://github.com/giampaolo/psutil/issues/971
                // - https://github.com/giampaolo/psutil/blob/642438375e685403b4cd60b0c0e25b80dd5a813d/psutil/_pslinux.py#L1316
                //
                // If it does match, then add the `device/` directory to the path.
                if path.join("device/temp1_input").exists() {
                    path.push("device");
                }
            }

            dirs.insert(path);
        }
    }

    let num_hwmon = dirs.len();

    if let Ok(read_dir) = Path::new("/sys/devices/platform").read_dir() {
        for entry in read_dir.flatten() {
            if entry.file_name().to_string_lossy().starts_with("coretemp.") {
                if let Ok(read_dir) = entry.path().join("hwmon").read_dir() {
                    for entry in read_dir.flatten() {
                        let path = entry.path();

                        if path.join("temp1_input").exists() {
                            // It's possible that there are dupes (represented by symlinks) - the easy
                            // way is to just substitute the parent directory and check if the hwmon
                            // variant exists already in a set.
                            //
                            // For more info, see https://github.com/giampaolo/psutil/pull/1822/files
                            if let Some(child) = path.file_name() {
                                let to_check_path = Path::new("/sys/class/hwmon").join(child);

                                if !dirs.contains(&to_check_path) {
                                    dirs.insert(path);
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    (dirs, num_hwmon)
}

#[inline]
fn read_to_string_lossy<P: AsRef<Path>>(path: P) -> Option<String> {
    fs::read(path)
        .map(|v| String::from_utf8_lossy(&v).trim().to_string())
        .ok()
}

#[inline]
fn humanize_name(name: String, sensor_name: Option<&String>) -> String {
    match sensor_name {
        Some(ty) => format!("{name} ({ty})"),
        None => name,
    }
}

#[inline]
fn counted_name(seen_names: &mut HashMap<String, u32>, name: String) -> String {
    if let Some(count) = seen_names.get_mut(&name) {
        *count += 1;
        format!("{name} ({count})")
    } else {
        seen_names.insert(name.clone(), 0);
        name
    }
}

#[inline]
fn finalize_name(
    hwmon_name: Option<String>, sensor_label: Option<String>,
    fallback_sensor_name: &Option<String>, seen_names: &mut HashMap<String, u32>,
) -> String {
    let candidate_name = match (hwmon_name, sensor_label) {
        (Some(name), Some(label)) => match (name.is_empty(), label.is_empty()) {
            (false, false) => {
                format!("{name}: {label}")
            }
            (true, false) => match fallback_sensor_name {
                Some(fallback) if !fallback.is_empty() => {
                    if label.is_empty() {
                        fallback.to_owned()
                    } else {
                        format!("{fallback}: {label}")
                    }
                }
                _ => {
                    if label.is_empty() {
                        EMPTY_NAME.to_string()
                    } else {
                        label
                    }
                }
            },
            (false, true) => name.to_owned(),
            (true, true) => EMPTY_NAME.to_string(),
        },
        (None, Some(label)) => match fallback_sensor_name {
            Some(fallback) if !fallback.is_empty() => {
                if label.is_empty() {
                    fallback.to_owned()
                } else {
                    format!("{fallback}: {label}")
                }
            }
            _ => {
                if label.is_empty() {
                    EMPTY_NAME.to_string()
                } else {
                    label
                }
            }
        },
        (Some(name), None) => {
            if name.is_empty() {
                EMPTY_NAME.to_string()
            } else {
                name
            }
        }
        (None, None) => match fallback_sensor_name {
            Some(sensor_name) if !sensor_name.is_empty() => sensor_name.to_owned(),
            _ => EMPTY_NAME.to_string(),
        },
    };

    counted_name(seen_names, candidate_name)
}

/// Whether the temperature should *actually* be read during enumeration. Uses a combination of
/// `power/runtime_status` if it is supported, and `device/power_state` as a fallback.
///
/// If `runtime_status` is supported, then it will return true only if it is in the "active" state.
/// If it is not supported, and we fall back to `device/power_state`, then it will return true
/// only if in D0 or unknown states.
/// If neither are found, it will always return true and be treated as "awake".
#[inline]
fn is_device_awake(path: &Path) -> bool {
    // Try checking `power/runtime_status` if it exists! For more information, see
    // https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-devices-power
    let runtime_status_path = path.join("power/runtime_status");
    if runtime_status_path.exists() {
        if let Ok(status) = fs::read_to_string(runtime_status_path) {
            match status.as_str() {
                "suspended" | "suspending" | "resuming" => {
                    return false;
                }
                "active" => {
                    return true;
                }
                _ => {}
            }
        }
    }

    // Otherwise, check if the device is in ACPI D3Cold.
    // Documented at https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-devices-power_state
    let power_state = path.join("device/power_state");
    if power_state.exists() {
        if let Ok(state) = fs::read_to_string(power_state) {
            // The zenpower3 kernel module (incorrectly?) reports "unknown", causing this check
            // to fail and temperatures to appear as zero instead of having the file not exist.
            //
            // Their self-hosted git instance has disabled sign up, so this bug cant be reported either.
            state == "D0" || state == "unknown"
        } else {
            true
        }
    } else {
        true
    }
}

/// Ge