vendor/sysinfo/src/linux/component.rs - toolchain/rustc - Git at Google

 // Take a look at the license at the top of the repository in the LICENSE file.

 // Information about values readable from `hwmon` sysfs.
 //
 // Values in /sys/class/hwmonN are `c_long` or `c_ulong`
 // transposed to rust we only read `u32` or `i32` values.
 use crate::ComponentExt;

 use std::collections::HashMap;
 use std::fs::{read_dir, File};
 use std::io::Read;
 use std::path::{Path, PathBuf};

 #[doc = include_str!("../../md_doc/component.md")]
 #[derive(Default)]
 pub struct Component {
     /// Optional associated device of a `Component`.
     device_model: Option<String>,
     /// The chip name.
     ///
     /// Kernel documentation extract:
     /// ```txt
     /// This should be a short, lowercase string, not containing
     /// whitespace, dashes, or the wildcard character '*'.
     /// This attribute represents the chip name. It is the only
     /// mandatory attribute.
     /// I2C devices get this attribute created automatically.
     /// ```
     name: String,
     /// Temperature current value
     /// - Read in: `temp[1-*]_input`.
     /// - Unit: read as millidegree Celsius converted to Celsius.
     temperature: Option<f32>,
     /// Maximum value computed by `sysinfo`.
     max: Option<f32>,
     /// Max threshold provided by the chip/kernel
     /// - Read in:`temp[1-*]_max`
     /// - Unit: read as millidegree Celsius converted to Celsius.
     threshold_max: Option<f32>,
     /// Min threshold provided by the chip/kernel.
     /// - Read in:`temp[1-*]_min`
     /// - Unit: read as millidegree Celsius converted to Celsius.
     threshold_min: Option<f32>,
     /// Critical threshold provided by the chip/kernel previous user write.
     /// Read in `temp[1-*]_crit`:
     /// Typically greater than corresponding temp_max values.
     /// - Unit: read as millidegree Celsius converted to Celsius.
     threshold_critical: Option<f32>,
     /// Sensor type, not common but can exist!
     ///
     /// Read in: `temp[1-*]_type` Sensor type selection.
     /// Values integer:
     /// - 1: CPU embedded diode
     /// - 2: 3904 transistor
     /// - 3: thermal diode
     /// - 4: thermistor
     /// - 5: AMD AMDSI
     /// - 6: Intel PECI
     /// Not all types are supported by all chips
     sensor_type: Option<TermalSensorType>,
     /// Component Label
     ///
     /// For formatting detail see `Component::label` function docstring.
     ///
     /// ## Linux implementation details
     ///
     /// read n: `temp[1-*]_label` Suggested temperature channel label.
     /// Value: Text string
     ///
     /// Should only be created if the driver has hints about what
     /// this temperature channel is being used for, and user-space
     /// doesn't. In all other cases, the label is provided by user-space.
     label: String,
     // TODO: not used now.
     // Historical minimum temperature
     // - Read in:`temp[1-*]_lowest
     // - Unit: millidegree Celsius
     //
     // Temperature critical min value, typically lower than
     // corresponding temp_min values.
     // - Read in:`temp[1-*]_lcrit`
     // - Unit: millidegree Celsius
     //
     // Temperature emergency max value, for chips supporting more than
     // two upper temperature limits. Must be equal or greater than
     // corresponding temp_crit values.
     // - temp[1-*]_emergency
     // - Unit: millidegree Celsius
     /// File to read current temperature shall be `temp[1-*]_input`
     /// It may be absent but we don't continue if absent.
     input_file: Option<PathBuf>,
     /// `temp[1-*]_highest file` to read if available highest value.
     highest_file: Option<PathBuf>,
 }

 // Read arbitrary data from sysfs.
 fn get_file_line(file: &Path, capacity: usize) -> Option<String> {
     let mut reader = String::with_capacity(capacity);
     let mut f = File::open(file).ok()?;
     f.read_to_string(&mut reader).ok()?;
     reader.truncate(reader.trim_end().len());
     Some(reader)
 }

 /// Designed at first for reading an `i32` or `u32` aka `c_long`
 /// from a `/sys/class/hwmon` sysfs file.
 fn read_number_from_file<N>(file: &Path) -> Option<N>
 where
     N: std::str::FromStr,
 {
     let mut reader = [0u8; 32];
     let mut f = File::open(file).ok()?;
     let n = f.read(&mut reader).ok()?;
     // parse and trim would complain about `\0`.
     let number = &reader[..n];
     let number = std::str::from_utf8(number).ok()?;
     let number = number.trim();
     // Assert that we cleaned a little bit that string.
     if cfg!(feature = "debug") {
         assert!(!number.contains('\n') && !number.contains('\0'));
     }
     number.parse().ok()
 }

 // Read a temperature from a `tempN_item` sensor form the sysfs.
 // number returned will be in mili-celsius.
 //
 // Don't call it on `label`, `name` or `type` file.
 #[inline]
 fn get_temperature_from_file(file: &Path) -> Option<f32> {
     let temp = read_number_from_file(file);
     convert_temp_celsius(temp)
 }

 /// Takes a raw temperature in mili-celsius and convert it to celsius.
 #[inline]
 fn convert_temp_celsius(temp: Option<i32>) -> Option<f32> {
     temp.map(|n| (n as f32) / 1000f32)
 }

 /// Information about thermal sensor. It may be unavailable as it's
 /// kernel module and chip dependent.
 enum TermalSensorType {
     /// 1: CPU embedded diode
     CPUEmbeddedDiode,
     /// 2: 3904 transistor
     Transistor3904,
     /// 3: thermal diode
     ThermalDiode,
     /// 4: thermistor
     Thermistor,
     /// 5: AMD AMDSI
     AMDAMDSI,
     /// 6: Intel PECI
     IntelPECI,
     /// Not all types are supported by all chips so we keep space for
     /// unknown sensors.
     Unknown(u8),
 }

 impl From<u8> for TermalSensorType {
     fn from(input: u8) -> Self {
         match input {
             0 => Self::CPUEmbeddedDiode,
             1 => Self::Transistor3904,
             3 => Self::ThermalDiode,
             4 => Self::Thermistor,
             5 => Self::AMDAMDSI,
             6 => Self::IntelPECI,
             n => Self::Unknown(n),
         }
     }
 }

 /// Check given `item` dispatch to read the right `file` with the right parsing and store data in
 /// given `component`. `id` is provided for `label` creation.
 fn fill_component(component: &mut Component, item: &str, folder: &Path, file: &str) {
     let hwmon_file = folder.join(file);
     match item {
         "type" => {
             component.sensor_type =
                 read_number_from_file::<u8>(&hwmon_file).map(TermalSensorType::from)
         }
         "input" => {
             let temperature = get_temperature_from_file(&hwmon_file);
             component.input_file = Some(hwmon_file);
             component.temperature = temperature;
             // Maximum know try to get it from `highest` if not available
             // use current temperature
             if component.max.is_none() {
                 component.max = temperature;
             }
         }
         "label" => component.label = get_file_line(&hwmon_file, 10).unwrap_or_default(),
         "highest" => {
             component.max = get_temperature_from_file(&hwmon_file).or(component.temperature);
             component.highest_file = Some(hwmon_file);
         }
         "max" => component.threshold_max = get_temperature_from_file(&hwmon_file),
         "min" => component.threshold_min = get_temperature_from_file(&hwmon_file),
         "crit" => component.threshold_critical = get_temperature_from_file(&hwmon_file),
         _ => {
             sysinfo_debug!(
                 "This hwmon-temp file is still not supported! Contributions are appreciated.;) {:?}",
                 hwmon_file,
             );
         }
     }
 }

 impl Component {
     /// Read out `hwmon` info (hardware monitor) from `folder`
     /// to get values' path to be used on refresh as well as files containing `max`,
     /// `critical value` and `label`. Then we store everything into `components`.
     ///
     /// Note that a thermal [Component] must have a way to read its temperature.
     /// If not, it will be ignored and not added into `components`.
     ///
     /// ## What is read:
     ///
     /// - Mandatory: `name` the name of the `hwmon`.
     /// - Mandatory: `tempN_input` Drop [Component] if missing
     /// - Optional: sensor `label`, in the general case content of `tempN_label`
     ///   see below for special cases
     /// - Optional: `label`
     /// - Optional: `/device/model`
     /// - Optional: hightest historic value in `tempN_hightest`.
     /// - Optional: max threshold value defined in `tempN_max`
     /// - Optional: critical threshold value defined in `tempN_crit`
     ///
     /// Where `N` is a `u32` associated to a sensor like `temp1_max`, `temp1_input`.
     ///
     /// ## Doc to Linux kernel API.
     ///
     /// Kernel hwmon API: https://www.kernel.org/doc/html/latest/hwmon/hwmon-kernel-api.html
     /// DriveTemp kernel API: https://docs.kernel.org/gpu/amdgpu/thermal.html#hwmon-interfaces
     /// Amdgpu hwmon interface: https://www.kernel.org/doc/html/latest/hwmon/drivetemp.html
     fn from_hwmon(components: &mut Vec<Component>, folder: &Path) -> Option<()> {
         let dir = read_dir(folder).ok()?;
         let mut matchings: HashMap<u32, Component> = HashMap::with_capacity(10);
         for entry in dir.flatten() {
             let entry = entry.path();
             let filename = entry.file_name().and_then(|x| x.to_str()).unwrap_or("");
             if entry.is_dir() || !filename.starts_with("temp") {
                 continue;
             }

             let (id, item) = filename.split_once('_')?;
             let id = id.get(4..)?.parse::<u32>().ok()?;

             let component = matchings.entry(id).or_insert_with(Component::default);
             let name = get_file_line(&folder.join("name"), 16);
             component.name = name.unwrap_or_default();
             let device_model = get_file_line(&folder.join("device/model"), 16);
             component.device_model = device_model;
             fill_component(component, item, folder, filename);
         }
         let compo = matchings
             .into_iter()
             .map(|(id, mut c)| {
                 // sysinfo expose a generic interface with a `label`.
                 // Problem: a lot of sensors don't have a label or a device model! ¯\_(ツ)_/¯
                 // So let's pretend we have a unique label!
                 // See the table in `Component::label` documentation for the table detail.
                 c.label = c.format_label("temp", id);
                 c
             })
             // Remove components without `tempN_input` file termal. `Component` doesn't support this kind of sensors yet
             .filter(|c| c.input_file.is_some());

         components.extend(compo);
         Some(())
     }

     /// Compute a label out of available information.
     /// See the table in `Component::label`'s documentation.
     fn format_label(&self, class: &str, id: u32) -> String {
         let Component {
             device_model,
             name,
             label,
             ..
         } = self;
         let has_label = !label.is_empty();
         match (has_label, device_model) {
             (true, Some(device_model)) => {
                 format!("{name} {label} {device_model} {class}{id}")
             }
             (true, None) => format!("{name} {label}"),
             (false, Some(device_model)) => format!("{name} {device_model}"),
             (false, None) => format!("{name} {class}{id}"),
         }
     }
 }

 impl ComponentExt for Component {
     fn temperature(&self) -> f32 {
         self.temperature.unwrap_or(f32::NAN)
     }

     fn max(&self) -> f32 {
         self.max.unwrap_or(f32::NAN)
     }

     fn critical(&self) -> Option<f32> {
         self.threshold_critical
     }

     fn label(&self) -> &str {
         &self.label
     }

     fn refresh(&mut self) {
         let current = self
             .input_file
             .as_ref()
             .and_then(|file| get_temperature_from_file(file.as_path()));
         // tries to read out kernel highest if not compute something from temperature.
         let max = self
             .highest_file
             .as_ref()
             .and_then(|file| get_temperature_from_file(file.as_path()))
             .or_else(|| {
                 let last = self.temperature?;
                 let current = current?;
                 Some(last.max(current))
             });
         self.max = max;
         self.temperature = current;
     }
 }

 pub(crate) fn get_components() -> Vec<Component> {
     let mut components = Vec::with_capacity(10);
     if let Ok(dir) = read_dir(Path::new("/sys/class/hwmon/")) {
         for entry in dir.flatten() {
             let entry = entry.path();
             if !entry.is_dir()
                 || !entry
                     .file_name()
                     .and_then(|x| x.to_str())
                     .unwrap_or("")
                     .starts_with("hwmon")
             {
                 continue;
             }
             Component::from_hwmon(&mut components, &entry);
         }
         components.sort_by(|c1, c2| c1.label.to_lowercase().cmp(&c2.label.to_lowercase()));
     }
     components
 }
	// Take a look at the license at the top of the repository in the LICENSE file.

	// Information about values readable from `hwmon` sysfs.
	//
	// Values in /sys/class/hwmonN are `c_long` or `c_ulong`
	// transposed to rust we only read `u32` or `i32` values.
	use crate::ComponentExt;

	use std::collections::HashMap;
	use std::fs::{read_dir, File};
	use std::io::Read;
	use std::path::{Path, PathBuf};

	#[doc = include_str!("../../md_doc/component.md")]
	#[derive(Default)]
	pub struct Component {
	/// Optional associated device of a `Component`.
	device_model: Option<String>,
	/// The chip name.
	///
	/// Kernel documentation extract:
	/// ```txt
	/// This should be a short, lowercase string, not containing
	/// whitespace, dashes, or the wildcard character '*'.
	/// This attribute represents the chip name. It is the only
	/// mandatory attribute.
	/// I2C devices get this attribute created automatically.
	/// ```
	name: String,
	/// Temperature current value
	/// - Read in: `temp[1-*]_input`.
	/// - Unit: read as millidegree Celsius converted to Celsius.
	temperature: Option<f32>,
	/// Maximum value computed by `sysinfo`.
	max: Option<f32>,
	/// Max threshold provided by the chip/kernel
	/// - Read in:`temp[1-*]_max`
	/// - Unit: read as millidegree Celsius converted to Celsius.
	threshold_max: Option<f32>,
	/// Min threshold provided by the chip/kernel.
	/// - Read in:`temp[1-*]_min`
	/// - Unit: read as millidegree Celsius converted to Celsius.
	threshold_min: Option<f32>,
	/// Critical threshold provided by the chip/kernel previous user write.
	/// Read in `temp[1-*]_crit`:
	/// Typically greater than corresponding temp_max values.
	/// - Unit: read as millidegree Celsius converted to Celsius.
	threshold_critical: Option<f32>,
	/// Sensor type, not common but can exist!
	///
	/// Read in: `temp[1-*]_type` Sensor type selection.
	/// Values integer:
	/// - 1: CPU embedded diode
	/// - 2: 3904 transistor
	/// - 3: thermal diode
	/// - 4: thermistor
	/// - 5: AMD AMDSI
	/// - 6: Intel PECI
	/// Not all types are supported by all chips
	sensor_type: Option<TermalSensorType>,
	/// Component Label
	///
	/// For formatting detail see `Component::label` function docstring.
	///
	/// ## Linux implementation details
	///
	/// read n: `temp[1-*]_label` Suggested temperature channel label.
	/// Value: Text string
	///
	/// Should only be created if the driver has hints about what
	/// this temperature channel is being used for, and user-space
	/// doesn't. In all other cases, the label is provided by user-space.
	label: String,
	// TODO: not used now.
	// Historical minimum temperature
	// - Read in:`temp[1-*]_lowest
	// - Unit: millidegree Celsius
	//
	// Temperature critical min value, typically lower than
	// corresponding temp_min values.
	// - Read in:`temp[1-*]_lcrit`
	// - Unit: millidegree Celsius
	//
	// Temperature emergency max value, for chips supporting more than
	// two upper temperature limits. Must be equal or greater than
	// corresponding temp_crit values.
	// - temp[1-*]_emergency
	// - Unit: millidegree Celsius
	/// File to read current temperature shall be `temp[1-*]_input`
	/// It may be absent but we don't continue if absent.
	input_file: Option<PathBuf>,
	/// `temp[1-*]_highest file` to read if available highest value.
	highest_file: Option<PathBuf>,
	}

	// Read arbitrary data from sysfs.
	fn get_file_line(file: &Path, capacity: usize) -> Option<String> {
	let mut reader = String::with_capacity(capacity);
	let mut f = File::open(file).ok()?;
	f.read_to_string(&mut reader).ok()?;
	reader.truncate(reader.trim_end().len());
	Some(reader)
	}

	/// Designed at first for reading an `i32` or `u32` aka `c_long`
	/// from a `/sys/class/hwmon` sysfs file.
	fn read_number_from_file<N>(file: &Path) -> Option<N>
	where
	N: std::str::FromStr,
	{
	let mut reader = [0u8; 32];
	let mut f = File::open(file).ok()?;
	let n = f.read(&mut reader).ok()?;
	// parse and trim would complain about `\0`.
	let number = &reader[..n];
	let number = std::str::from_utf8(number).ok()?;
	let number = number.trim();
	// Assert that we cleaned a little bit that string.
	if cfg!(feature = "debug") {
	assert!(!number.contains('\n') && !number.contains('\0'));
	}
	number.parse().ok()
	}

	// Read a temperature from a `tempN_item` sensor form the sysfs.
	// number returned will be in mili-celsius.
	//
	// Don't call it on `label`, `name` or `type` file.
	#[inline]
	fn get_temperature_from_file(file: &Path) -> Option<f32> {
	let temp = read_number_from_file(file);
	convert_temp_celsius(temp)
	}

	/// Takes a raw temperature in mili-celsius and convert it to celsius.
	#[inline]
	fn convert_temp_celsius(temp: Option<i32>) -> Option<f32> {
	temp.map(\|n\| (n as f32) / 1000f32)
	}

	/// Information about thermal sensor. It may be unavailable as it's
	/// kernel module and chip dependent.
	enum TermalSensorType {
	/// 1: CPU embedded diode
	CPUEmbeddedDiode,
	/// 2: 3904 transistor
	Transistor3904,
	/// 3: thermal diode
	ThermalDiode,
	/// 4: thermistor
	Thermistor,
	/// 5: AMD AMDSI
	AMDAMDSI,
	/// 6: Intel PECI
	IntelPECI,
	/// Not all types are supported by all chips so we keep space for
	/// unknown sensors.
	Unknown(u8),
	}

	impl From<u8> for TermalSensorType {
	fn from(input: u8) -> Self {
	match input {
	0 => Self::CPUEmbeddedDiode,
	1 => Self::Transistor3904,
	3 => Self::ThermalDiode,
	4 => Self::Thermistor,
	5 => Self::AMDAMDSI,
	6 => Self::IntelPECI,
	n => Self::Unknown(n),
	}
	}
	}

	/// Check given `item` dispatch to read the right `file` with the right parsing and store data in
	/// given `component`. `id` is provided for `label` creation.
	fn fill_component(component: &mut Component, item: &str, folder: &Path, file: &str) {
	let hwmon_file = folder.join(file);
	match item {
	"type" => {
	component.sensor_type =
	read_number_from_file::<u8>(&hwmon_file).map(TermalSensorType::from)
	}
	"input" => {
	let temperature = get_temperature_from_file(&hwmon_file);
	component.input_file = Some(hwmon_file);
	component.temperature = temperature;
	// Maximum know try to get it from `highest` if not available
	// use current temperature
	if component.max.is_none() {
	component.max = temperature;
	}
	}
	"label" => component.label = get_file_line(&hwmon_file, 10).unwrap_or_default(),
	"highest" => {
	component.max = get_temperature_from_file(&hwmon_file).or(component.temperature);
	component.highest_file = Some(hwmon_file);
	}
	"max" => component.threshold_max = get_temperature_from_file(&hwmon_file),
	"min" => component.threshold_min = get_temperature_from_file(&hwmon_file),
	"crit" => component.threshold_critical = get_temperature_from_file(&hwmon_file),
	_ => {
	sysinfo_debug!(
	"This hwmon-temp file is still not supported! Contributions are appreciated.;) {:?}",
	hwmon_file,
	);
	}
	}
	}

	impl Component {
	/// Read out `hwmon` info (hardware monitor) from `folder`
	/// to get values' path to be used on refresh as well as files containing `max`,
	/// `critical value` and `label`. Then we store everything into `components`.
	///
	/// Note that a thermal [Component] must have a way to read its temperature.
	/// If not, it will be ignored and not added into `components`.
	///
	/// ## What is read:
	///
	/// - Mandatory: `name` the name of the `hwmon`.
	/// - Mandatory: `tempN_input` Drop [Component] if missing
	/// - Optional: sensor `label`, in the general case content of `tempN_label`
	/// see below for special cases
	/// - Optional: `label`
	/// - Optional: `/device/model`
	/// - Optional: hightest historic value in `tempN_hightest`.
	/// - Optional: max threshold value defined in `tempN_max`
	/// - Optional: critical threshold value defined in `tempN_crit`
	///
	/// Where `N` is a `u32` associated to a sensor like `temp1_max`, `temp1_input`.
	///
	/// ## Doc to Linux kernel API.
	///
	/// Kernel hwmon API: https://www.kernel.org/doc/html/latest/hwmon/hwmon-kernel-api.html
	/// DriveTemp kernel API: https://docs.kernel.org/gpu/amdgpu/thermal.html#hwmon-interfaces
	/// Amdgpu hwmon interface: https://www.kernel.org/doc/html/latest/hwmon/drivetemp.html
	fn from_hwmon(components: &mut Vec<Component>, folder: &Path) -> Option<()> {
	let dir = read_dir(folder).ok()?;
	let mut matchings: HashMap<u32, Component> = HashMap::with_capacity(10);
	for entry in dir.flatten() {
	let entry = entry.path();
	let filename = entry.file_name().and_then(\|x\| x.to_str()).unwrap_or("");
	if entry.is_dir() \|\| !filename.starts_with("temp") {
	continue;
	}

	let (id, item) = filename.split_once('_')?;
	let id = id.get(4..)?.parse::<u32>().ok()?;

	let component = matchings.entry(id).or_insert_with(Component::default);
	let name = get_file_line(&folder.join("name"), 16);
	component.name = name.unwrap_or_default();
	let device_model = get_file_line(&folder.join("device/model"), 16);
	component.device_model = device_model;
	fill_component(component, item, folder, filename);
	}
	let compo = matchings
	.into_iter()
	.map(\|(id, mut c)\| {
	// sysinfo expose a generic interface with a `label`.
	// Problem: a lot of sensors don't have a label or a device model! ¯\_(ツ)_/¯
	// So let's pretend we have a unique label!
	// See the table in `Component::label` documentation for the table detail.
	c.label = c.format_label("temp", id);
	c
	})
	// Remove components without `tempN_input` file termal. `Component` doesn't support this kind of sensors yet
	.filter(\|c\| c.input_file.is_some());

	components.extend(compo);
	Some(())
	}

	/// Compute a label out of available information.
	/// See the table in `Component::label`'s documentation.
	fn format_label(&self, class: &str, id: u32) -> String {
	let Component {
	device_model,
	name,
	label,
	..
	} = self;
	let has_label = !label.is_empty();
	match (has_label, device_model) {
	(true, Some(device_model)) => {
	format!("{name} {label} {device_model} {class}{id}")
	}
	(true, None) => format!("{name} {label}"),
	(false, Some(device_model)) => format!("{name} {device_model}"),
	(false, None) => format!("{name} {class}{id}"),
	}
	}
	}

	impl ComponentExt for Component {
	fn temperature(&self) -> f32 {
	self.temperature.unwrap_or(f32::NAN)
	}

	fn max(&self) -> f32 {
	self.max.unwrap_or(f32::NAN)
	}

	fn critical(&self) -> Option<f32> {
	self.threshold_critical
	}

	fn label(&self) -> &str {
	&self.label
	}

	fn refresh(&mut self) {
	let current = self
	.input_file
	.as_ref()
	.and_then(\|file\| get_temperature_from_file(file.as_path()));
	// tries to read out kernel highest if not compute something from temperature.
	let max = self
	.highest_file
	.as_ref()
	.and_then(\|file\| get_temperature_from_file(file.as_path()))
	.or_else(\|\| {
	let last = self.temperature?;
	let current = current?;
	Some(last.max(current))
	});
	self.max = max;
	self.temperature = current;
	}
	}

	pub(crate) fn get_components() -> Vec<Component> {
	let mut components = Vec::with_capacity(10);
	if let Ok(dir) = read_dir(Path::new("/sys/class/hwmon/")) {
	for entry in dir.flatten() {
	let entry = entry.path();
	if !entry.is_dir()
	\|\| !entry
	.file_name()
	.and_then(\|x\| x.to_str())
	.unwrap_or("")
	.starts_with("hwmon")
	{
	continue;
	}
	Component::from_hwmon(&mut components, &entry);
	}
	components.sort_by(\|c1, c2\| c1.label.to_lowercase().cmp(&c2.label.to_lowercase()));
	}
	components
	}