resourced/src/power.rs

// Copyright 2022 The ChromiumOS Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use std::fs::read_to_string;
use std::path::Path;
use std::path::PathBuf;
use std::str::FromStr;

use anyhow::Context;
use anyhow::Result;
use log::info;

use crate::arch;
use crate::common;
use crate::common::read_from_file;
use crate::common::BatterySaverMode;
use crate::common::FullscreenVideo;
use crate::common::GameMode;
use crate::common::RTCAudioActive;
use crate::common::VmBootMode;
use crate::config::ConfigProvider;
use crate::config::CpuOfflinePreference;
use crate::config::Governor;
use crate::config::PowerPreferences;
use crate::config::PowerPreferencesType;
use crate::config::PowerSourceType;
use crate::cpu_utils::hotplug_cpus;
use crate::cpu_utils::write_to_cpu_policy_patterns;
use crate::cpu_utils::HotplugCpuAction;

const POWER_SUPPLY_PATH: &str = "sys/class/power_supply";
const POWER_SUPPLY_ONLINE: &str = "online";
const POWER_SUPPLY_STATUS: &str = "status";
const GLOBAL_ONDEMAND_PATH: &str = "sys/devices/system/cpu/cpufreq/ondemand";

pub trait PowerSourceProvider {
    /// Returns the current power source of the system.
    fn get_power_source(&self) -> Result<PowerSourceType>;
}

/// See the `POWER_SUPPLY_STATUS_` enum in the linux kernel.
/// These values are intended to describe the battery status. They are also used
/// to describe the charger status, which adds a little bit of confusion. A
/// charger will only return `Charging` or `NotCharging`.
#[derive(Copy, Clone, Debug, PartialEq)]
enum PowerSupplyStatus {
    Unknown,
    Charging,
    Discharging,
    NotCharging,
    Full,
}

impl FromStr for PowerSupplyStatus {
    type Err = anyhow::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let s = s.trim_end();

        match s {
            "Unknown" => Ok(PowerSupplyStatus::Unknown),
            "Charging" => Ok(PowerSupplyStatus::Charging),
            "Discharging" => Ok(PowerSupplyStatus::Discharging),
            "Not charging" => Ok(PowerSupplyStatus::NotCharging),
            "Full" => Ok(PowerSupplyStatus::Full),
            _ => anyhow::bail!("Unknown Power Supply Status: '{}'", s),
        }
    }
}

#[derive(Clone, Debug)]
pub struct DirectoryPowerSourceProvider {
    root: PathBuf,
}

impl DirectoryPowerSourceProvider {
    pub fn new(root: PathBuf) -> Self {
        Self { root }
    }
}

impl PowerSourceProvider for DirectoryPowerSourceProvider {
    /// Iterates through all the power supplies in sysfs and looks for the `online` property.
    /// This indicates an external power source is connected (AC), but it doesn't necessarily
    /// mean it's powering the system. Tests will sometimes disable the charger to get power
    /// measurements. In order to determine if the charger is powering the system we need to
    /// look at the `status` property. If there is no charger connected and powering the system
    /// then we assume we are running off a battery (DC).
    fn get_power_source(&self) -> Result<PowerSourceType> {
        let path = self.root.join(POWER_SUPPLY_PATH);

        if !path.exists() {
            return Ok(PowerSourceType::DC);
        }

        let dirs = path
            .read_dir()
            .with_context(|| format!("Failed to enumerate power supplies in {}", path.display()))?;

        for result in dirs {
            let charger_path = result?;

            let online_path = charger_path.path().join(POWER_SUPPLY_ONLINE);

            if !online_path.exists() {
                continue;
            }

            let online: u32 = read_from_file(&online_path)
                .with_context(|| format!("Error reading online from {}", online_path.display()))?;

            if online != 1 {
                continue;
            }

            let status_path = charger_path.path().join(POWER_SUPPLY_STATUS);

            if !status_path.exists() {
                continue;
            }

            let status_string = match read_to_string(&status_path) {
                Ok(data) => data,
                Err(e) => {
                    info!(
                        "Error reading status from {}, error: {}",
                        status_path.display(),
                        e
                    );
                    // On some boards, reading some power supply status may return ENODATA, it's an
                    // uncategorized Rust IO error kind. Continue checking other power supplies.
                    continue;
                }
            };

            let status_result = PowerSupplyStatus::from_str(&status_string);

            let status = match status_result {
                Err(_) => {
                    info!(
                        "Failure parsing '{}' from {}",
                        status_string,
                        status_path.display()
                    );
                    continue;
                }
                Ok(status) => status,
            };

            if status != PowerSupplyStatus::Charging {
                continue;
            }

            return Ok(PowerSourceType::AC);
        }

        Ok(PowerSourceType::DC)
    }
}

pub trait PowerPreferencesManager {
    /// Chooses a [power preference](PowerPreferences) using the parameters and the
    /// system's current power source. It then applies it to the system.
    ///
    /// If more then one activity is active, the following priority list is used
    /// to determine which [power preference](PowerPreferences) to apply. If there is no
    /// power preference defined for an activity, the next activity in the list will be tried.
    ///
    /// 1) [Borealis Gaming](PowerPreferencesType::BorealisGaming)
    /// 2) [ARCVM Gaming](PowerPreferencesType::ArcvmGaming)
    /// 3) [WebRTC](PowerPreferencesType::WebRTC)
    /// 4) [Fullscreen Video](PowerPreferencesType::Fullscreen)
    /// 5) [VM boot Mode] (PowerPreferencesType::VmBoot)
    ///
    /// The [default](PowerPreferencesType::Default) preference will be applied when no
    /// activity is active.
    fn update_power_preferences(
        &self,
        rtc: common::RTCAudioActive,
        fullscreen: common::FullscreenVideo,
        game: common::GameMode,
        vmboot: common::VmBootMode,
        batterysaver: common::BatterySaverMode,
    ) -> Result<()>;
    fn get_root(&self) -> &Path;
}

#[derive(Clone, Debug)]
/// Applies [power preferences](PowerPreferences) to the system by writing to
/// the system's sysfs nodes.
///
/// This struct is using generics for the [ConfigProvider](ConfigProvider) and
/// [PowerSourceProvider] to make unit testing easier.
pub struct DirectoryPowerPreferencesManager<P: PowerSourceProvider> {
    root: PathBuf,
    config_provider: ConfigProvider,
    power_source_provider: P,
}

impl<P: PowerSourceProvider> DirectoryPowerPreferencesManager<P> {
    #[cfg(test)]
    pub fn new(root: &Path, config_provider: ConfigProvider, power_source_provider: P) -> Self {
        let root = root.to_path_buf();
        Self {
            root: root.to_path_buf(),
            config_provider,
            power_source_provider,
        }
    }

    // The global ondemand parameters are in /sys/devices/system/cpu/cpufreq/ondemand/.
    fn set_global_ondemand_governor_value(&self, attr: &str, value: u32) -> Result<()> {
        let path = self.root.join(GLOBAL_ONDEMAND_PATH).join(attr);

        let current_value_str = read_to_string(&path)
            .with_context(|| format!("Error reading ondemand parameter from {}", path.display()))?;
        let current_value = current_value_str.trim_end_matches('\n').parse::<u32>()?;

        // Check current value before writing to avoid permission error when the new value and
        // current value are the same but resourced didn't own the parameter file.
        if current_value != value {
            std::fs::write(&path, value.to_string()).with_context(|| {
                format!("Error writing {} {} to {}", attr, value, path.display())
            })?;

            info!("Updating ondemand {} to {}", attr, value);
        }

        Ok(())
    }

    // The per-policy ondemand parameters are in /sys/devices/system/cpu/cpufreq/policy*/ondemand/.
    fn set_per_policy_ondemand_governor_value(&self, attr: &str, value: u32) -> Result<()> {
        const ONDEMAND_PATTERN: &str = "sys/devices/system/cpu/cpufreq/policy*/ondemand";
        let pattern = self
            .root
            .join(ONDEMAND_PATTERN)
            .join(attr)
            .to_str()
            .context("Cannot convert ondemand path to string")?
            .to_owned();
        write_to_cpu_policy_patterns(&pattern, &value.to_string())
    }

    fn set_scaling_governor(&self, new_governor: &str) -> Result<()> {
        const GOVERNOR_PATTERN: &str = "sys/devices/system/cpu/cpufreq/policy*/scaling_governor";
        let pattern = self
            .root
            .join(GOVERNOR_PATTERN)
            .to_str()
            .context("Cannot convert scaling_governor path to string")?
            .to_owned();

        write_to_cpu_policy_patterns(&pattern, new_governor)
    }

    fn apply_governor_preferences(&self, governor: Governor) -> Result<()> {
        self.set_scaling_governor(governor.name())?;

        if let Governor::Ondemand {
            powersave_bias,
            sampling_rate,
        } = governor
        {
            let global_path = self.root.join(GLOBAL_ONDEMAND_PATH);

            // There are 2 use cases now:
            // 1. on guybrush, the scaling_governor is always ondemand, the ondemand directory is
            //    chowned to resourced so resourced can set the ondemand parameters.
            // 2. on herobrine, resourced only changes the scaling_governor, so the permission of
            //    the new governor's sysfs nodes doesn't matter.
            // TODO: support changing both the scaling_governor and the governor's parameters.

            // The ondemand tunable could be global (system-wide) or per-policy, depending on the
            // scaling driver in use [1]. The global ondemand tunable is in
            // /sys/devices/system/cpu/cpufreq/ondemand. The per-policy ondemand tunable is in
            // /sys/devices/system/cpu/cpufreq/policy*/ondemand.
            //
            // [1]: https://www.kernel.org/doc/html/latest/admin-guide/pm/cpufreq.html
            if global_path.exists() {
                self.set_global_ondemand_governor_value("powersave_bias", powersave_bias)?;

                if let Some(sampling_rate) = sampling_rate {
                    self.set_global_ondemand_governor_value("sampling_rate", sampling_rate)?;
                }
            } else {
                self.set_per_policy_ondemand_governor_value("powersave_bias", powersave_bias)?;
                if let Some(sampling_rate) = sampling_rate {
                    self.set_per_policy_ondemand_governor_value("sampling_rate", sampling_rate)?;
                }
            }
        }

        Ok(())
    }

    fn apply_power_preferences(&self, preferences: PowerPreferences) -> Result<()> {
        arch::apply_platform_power_preferences(self.get_root(), &preferences)?;

        if let Some(governor) = preferences.governor {
            self.apply_governor_preferences(governor)?
        }

        Ok(())
    }

    fn apply_cpu_hotplug(&self, preferences: PowerPreferences) -> Result<()> {
        match preferences.cpu_offline {
            Some(CpuOfflinePreference::Smt { min_active_threads }) => hotplug_cpus(
                self.get_root(),
                HotplugCpuAction::OfflineSMT { min_active_threads },
            )?,
            Some(CpuOfflinePreference::Half { min_active_threads }) => hotplug_cpus(
                self.get_root(),
                HotplugCpuAction::OfflineHalf { min_active_threads },
            )?,
            Some(CpuOfflinePreference::SmallCore { min_active_threads }) => hotplug_cpus(
                self.get_root(),
                HotplugCpuAction::OfflineSmallCore { min_active_threads },
            )?,
            None => {
                hotplug_cpus(self.get_root(), HotplugCpuAction::OnlineAll)?;
            }
        }

        Ok(())
    }

    fn apply_cpufreq_boost(&self, preferences: PowerPreferences) -> Result<()> {
        let boost_value = if preferences.cpufreq_disable_boost {
            // Disable boost by writing '0'.
            "0"
        } else {
            // Enable boost by writing '1'.
            "1"
        };

        const CPUFREQ_BOOST_PATH: &str = "sys/devices/system/cpu/cpufreq/boost";
        let cpufreq_boost_path = self.root.join(CPUFREQ_BOOST_PATH);
        if cpufreq_boost_path.exists() {
            let boost = std::fs::read_to_string(&cpufreq_boost_path)?;

            if boost.trim() != boost_value {
                std::fs::write(&cpufreq_boost_path, boost_value).with_context(|| {
                    format!(
                        "Error writing {} to {}",
                        boost_value,
                        cpufreq_boost_path.display()
                    )
                })?;

                info!("Updating cpufreq boost {}", boost_value);
            }
        }

        Ok(())
    }
}

impl<P: PowerSourceProvider> PowerPreferencesManager for DirectoryPowerPreferencesManager<P> {
    fn update_power_preferences(
        &self,
        rtc: RTCAudioActive,
        fullscreen: FullscreenVideo,
        game: GameMode,
        vmboot: VmBootMode,
        batterysaver: BatterySaverMode,
    ) -> Result<()> {
        let mut preferences: Option<PowerPreferences> = None;

        let power_source = self.power_source_provider.get_power_source()?;

        info!("Power source {:?}", power_source);

        if batterysaver == BatterySaverMode::Active {
            preferences = self
                .config_provider
                .read_power_preferences(power_source, PowerPreferencesType::BatterySaver)?;
        } else if game == GameMode::Borealis {
            preferences = self
                .config_provider
                .read_power_preferences(power_source, PowerPreferencesType::BorealisGaming)?;
        } else if game == GameMode::Arc {
            preferences = self
                .config_provider
                .read_power_preferences(power_source, PowerPreferencesType::ArcvmGaming)?;
        }

        if preferences.is_none() && rtc == RTCAudioActive::Active {
            preferences = self
                .config_provider
                .read_power_preferences(power_source, PowerPreferencesType::WebRTC)?;
        }

        if preferences.is_none() && fullscreen == FullscreenVideo::Active {
            preferences = self
                .config_provider
                .read_power_preferences(power_source, PowerPreferencesType::Fullscreen)?;
        }

        if preferences.is_none() && vmboot == VmBootMode::Active {
            preferences = self
                .config_provider
                .read_power_preferences(power_source, PowerPreferencesType::VmBoot)?;
        }

        if preferences.is_none() {
            preferences = self
                .config_provider
                .read_power_preferences(power_source, PowerPreferencesType::Default)?;
        }

        // For non-dynamic EPP, it may need default EPP
        let mut need_default_epp = true;
        if let Some(preferences) = preferences {
            self.apply_cpu_hotplug(preferences)?;
            self.apply_power_preferences(preferences)?;
            self.apply_cpufreq_boost(preferences)?;
            if preferences.epp.is_some() {
                need_default_epp = false;
            }
        }

        arch::apply_platform_power_settings(
            self.get_root(),
            power_source,
            rtc,
            fullscreen,
            batterysaver,
            need_default_epp, /* For x86 non-dynamic EPP */
        )?;

        Ok(())
    }

    fn get_root(&self) -> &Path {
        self.root.as_path()
    }
}

pub fn new_directory_power_preferences_manager(
    root: &Path,
    config_provider: ConfigProvider,
) -> DirectoryPowerPreferencesManager<DirectoryPowerSourceProvider> {
    let root = root.to_path_buf();
    DirectoryPowerPreferencesManager {
        root: root.clone(),
        config_provider,
        power_source_provider: DirectoryPowerSourceProvider::new(root),
    }
}

#[cfg(test)]
mod tests {
    use std::fs;
    use std::path::Path;

    use tempfile::tempdir;

    use super::*;
    use crate::test_utils::*;

    #[test]
    fn test_parse_power_supply_status() {
        assert_eq!(
            PowerSupplyStatus::from_str("Unknown\n").unwrap(),
            PowerSupplyStatus::Unknown
        );
        assert_eq!(
            PowerSupplyStatus::from_str("Charging\n").unwrap(),
            PowerSupplyStatus::Charging
        );
        assert_eq!(
            PowerSupplyStatus::from_str("Discharging\n").unwrap(),
            PowerSupplyStatus::Discharging
        );
        assert_eq!(
            PowerSupplyStatus::from_str("Not charging\n").unwrap(),
            PowerSupplyStatus::NotCharging
        );
        assert_eq!(
            PowerSupplyStatus::from_str("Full\n").unwrap(),
            PowerSupplyStatus::Full
        );

        assert!(PowerSupplyStatus::from_str("").is_err());
        assert!(PowerSupplyStatus::from_str("abc").is_err());
    }

    #[test]
    fn test_power_source_provider_empty_root() {
        let root = tempdir().unwrap();

        let provider = DirectoryPowerSourceProvider {
            root: root.path().to_path_buf(),
        };

        let power_source = provider.get_power_source().unwrap();

        assert_eq!(power_source, PowerSourceType::DC);
    }

    const POWER_SUPPLY_PATH: &str = "sys/class/power_supply";

    #[test]
    fn test_power_source_provider_empty_path() {
        let root = tempdir().unwrap();

        let path = root.path().join(POWER_SUPPLY_PATH);
        fs::create_dir_all(path).unwrap();

        let provider = DirectoryPowerSourceProvider {
            root: root.path().to_path_buf(),
        };

        let power_source = provider.get_power_source().unwrap();

        assert_eq!(power_source, PowerSourceType::DC);
    }

    /// Tests that the `DirectoryPowerSourceProvider` can parse the charger sysfs
    /// `online` and `status` attributes.
    #[test]
    fn test_power_source_provider_disconnected_then_connected() {
        let root = tempdir().unwrap();

        let path = root.path().join(POWER_SUPPLY_PATH);
        fs::create_dir_all(&path).unwrap();

        let provider = DirectoryPowerSourceProvider {
            root: root.path().to_path_buf(),
        };

        let charger = path.join("charger-1");
        fs::create_dir_all(&charger).unwrap();
        let online = charger.join("online");

        fs::write(&online, b"0").unwrap();
        let power_source = provider.get_power_source().unwrap();
        assert_eq!(power_source, PowerSourceType::DC);

        let status = charger.join("status");
        fs::write(&online, b"1").unwrap();
        fs::write(&status, b"Charging\n").unwrap();
        let power_source = provider.get_power_source().unwrap();
        assert_eq!(power_source, PowerSourceType::AC);

        fs::write(&online, b"1").unwrap();
        fs::write(&status, b"Not Charging\n").unwrap();
        let power_source = provider.get_power_source().unwrap();
        assert_eq!(power_source, PowerSourceType::DC);
    }

    fn write_global_powersave_bias(root: &Path, value: u32) -> Result<()> {
        let ondemand_path = root.join("sys/devices/system/cpu/cpufreq/ondemand");
        fs::create_dir_all(&ondemand_path)?;

        std::fs::write(
            ondemand_path.join("powersave_bias"),
            value.to_string() + "\n",
        )?;

        Ok(())
    }

    fn read_global_powersave_bias(root: &Path) -> Result<String> {
        let powersave_bias_path = root
            .join("sys/devices/system/cpu/cpufreq/ondemand")
            .join("powersave_bias");

        let mut powersave_bias = std::fs::read_to_string(powersave_bias_path)?;
        if powersave_bias.ends_with('\n') {
            powersave_bias.pop();
        }

        Ok(powersave_bias)
    }

    fn write_global_sampling_rate(root: &Path, value: u32) -> Result<()> {
        let ondemand_path = root.join("sys/devices/system/cpu/cpufreq/ondemand");
        fs::create_dir_all(&ondemand_path)?;

        std::fs::write(ondemand_path.join("sampling_rate"), value.to_string())?;

        Ok(())
    }

    fn read_global_sampling_rate(root: &Path) -> Result<String> {
        let sampling_rate_path = root
            .join("sys/devices/system/cpu/cpufreq/ondemand")
            .join("sampling_rate");

        let mut sampling_rate = std::fs::read_to_string(sampling_rate_path)?;
        if sampling_rate.ends_with('\n') {
            sampling_rate.pop();
        }

        Ok(sampling_rate)
    }

    fn read_global_cpufreq_boost(root: &Path) -> Result<String> {
        let cpufreq_boost_path = root.join("sys/devices/system/cpu/cpufreq/boost");

        let mut boost = std::fs::read_to_string(cpufreq_boost_path)?;
        boost = boost.trim().to_string();

        Ok(boost)
    }

    fn write_global_cpufreq_boost(root: &Path, value: u32) -> Result<()> {
        let cpufreq_boost_path = root.join("sys/devices/system/cpu/cpufreq");
        fs::create_dir_all(&cpufreq_boost_path)?;

        std::fs::write(cpufreq_boost_path.join("boost"), value.to_string())?;

        Ok(())
    }

    #[test]
    fn test_power_update_power_preferences_wrong_governor() {
        let root = tempdir().unwrap();

        test_write_cpuset_root_cpus(root.path(), "0-3");
        let power_source_provider = FakePowerSourceProvider {
            power_source: PowerSourceType::AC,
        };

        let fake_config = FakeConfig::new();
        let config_provider = fake_config.provider();

        let manager = DirectoryPowerPreferencesManager {
            root: root.path().to_path_buf(),
            config_provider,
            power_source_provider,
        };

        manager
            .update_power_preferences(
                common::RTCAudioActive::Inactive,
                common::FullscreenVideo::Inactive,
                common::GameMode::Off,
                common::VmBootMode::Inactive,
                common::BatterySaverMode::Inactive,
            )
            .unwrap();

        // We shouldn't have written anything.
        let powersave_bias = read_global_powersave_bias(root.path());
        assert!(powersave_bias.is_err());
    }

    #[test]
    fn test_power_update_power_preferences_none() {
        let root = tempdir().unwrap();

        write_global_powersave_bias(root.path(), 0).unwrap();
        write_global_sampling_rate(root.path(), 2000).unwrap();
        test_write_cpuset_root_cpus(root.path(), "0-3");

        let power_source_provider = FakePowerSourceProvider {
            power_source: PowerSourceType::AC,
        };

        let fake_config = FakeConfig::new();
        let config_provider = fake_config.provider();

        let manager = DirectoryPowerPreferencesManager {
            root: root.path().to_path_buf(),
            config_provider,
            power_source_provider,
        };

        manager
            .update_power_preferences(
                common::RTCAudioActive::Inactive,
                common::FullscreenVideo::Inactive,
                common::GameMode::Off,
                common::VmBootMode::Inactive,
                common::BatterySaverMode::Inactive,
            )
            .unwrap();

        let powersave_bias = read_global_powersave_bias(root.path()).unwrap();
        assert_eq!(powersave_bias, "0");

        let sampling_rate = read_global_sampling_rate(root.path()).unwrap();
        assert_eq!(sampling_rate, "2000");
    }

    #[test]
    fn test_power_update_power_preferences_default_ac() {
        let root = tempdir().unwrap();

        write_global_powersave_bias(root.path(), 0).unwrap();
        write_global_sampling_rate(root.path(), 2000).unwrap();
        write_global_cpufreq_boost(root.path(), 1).unwrap();
        test_write_cpuset_root_cpus(root.path(), "0-3");

        let power_source_provider = FakePowerSourceProvider {
            power_source: PowerSourceType::AC,
        };

        let mut fake_config = FakeConfig::new();
        fake_config.write_power_preference(
            PowerSourceType::AC,
            PowerPreferencesType::Default,
            &PowerPreferences {
                governor: Some(Governor::Ondemand {
                    powersave_bias: 200,
                    sampling_rate: Some(16000),
                }),
                epp: None,
                cpu_offline: None,
                cpufreq_disable_boost: false,
            },
        );
        let config_provider = fake_config.provider();

        let manager = DirectoryPowerPreferencesManager {
            root: root.path().to_path_buf(),
            config_provider,
            power_source_provider,
        };

        manager
            .update_power_preferences(
                common::RTCAudioActive::Inactive,
                common::FullscreenVideo::Inactive,
                common::GameMode::Off,
                common::VmBootMode::Inactive,
                common::BatterySaverMode::Inactive,
            )
            .unwrap();

        let powersave_bias = read_global_powersave_bias(root.path()).unwrap();
        assert_eq!(powersave_bias, "200");

        let sampling_rate = read_global_sampling_rate(root.path()).unwrap();
        assert_eq!(sampling_rate, "16000");

        let cpufreq_boost = read_global_cpufreq_boost(root.path()).unwrap();
        assert_eq!(cpufreq_boost, "1");
    }

    #[test]
    fn test_power_update_power_preferences_default_dc() {
        let root = tempdir().unwrap();

        write_global_powersave_bias(root.path(), 0).unwrap();
        write_global_sampling_rate(root.path(), 2000).unwrap();
        write_global_cpufreq_boost(root.path(), 1).unwrap();
        test_write_cpuset_root_cpus(root.path(), "0-3");

        let power_source_provider = FakePowerSourceProvider {
            power_source: PowerSourceType::DC,
        };

        let mut fake_config = FakeConfig::new();
        fake_config.write_power_preference(
            PowerSourceType::DC,
            PowerPreferencesType::Default,
            &PowerPreferences {
                governor: Some(Governor::Ondemand {
                    powersave_bias: 200,
                    sampling_rate: None,
                }),
                epp: None,
                cpu_offline: None,
                cpufreq_disable_boost: true,
            },
        );
        let config_provider = fake_config.provider();

        let manager = DirectoryPowerPreferencesManager {
            root: root.path().to_path_buf(),
            config_provider,
            power_source_provider,
        };

        manager
            .update_power_preferences(
                common::RTCAudioActive::Inactive,
                common::FullscreenVideo::Inactive,
                common::GameMode::Off,
                common::VmBootMode::Inactive,
                common::BatterySaverMode::Inactive,
            )
            .unwrap();

        let powersave_bias = read_global_powersave_bias(root.path()).unwrap();
        assert_eq!(powersave_bias, "200");

        let sampling_rate = read_global_sampling_rate(root.path()).unwrap();
        assert_eq!(sampling_rate, "2000");

        let cpufreq_boost = read_global_cpufreq_boost(root.path()).unwrap();
        assert_eq!(cpufreq_boost, "0");
    }

    #[test]
    fn test_power_update_power_preferences_default_rtc_active() {
        let root = tempdir().unwrap();

        write_global_powersave_bias(root.path(), 0).unwrap();
        write_global_sampling_rate(root.path(), 2000).unwrap();
        test_write_cpuset_root_cpus(root.path(), "0-3");

        let power_source_provider = FakePowerSourceProvider {
            power_source: PowerSourceType::AC,
        };

        let mut fake_config = FakeConfig::new();
        fake_config.write_power_preference(
            PowerSourceType::AC,
            PowerPreferencesType::Default,
            &PowerPreferences {
                governor: Some(Governor::Ondemand {
                    powersave_bias: 200,
                    sampling_rate: Some(4000),
                }),
                epp: None,
                cpu_offline: None,
                cpufreq_disable_boost: false,
            },
        );
        let config_provider = fake_config.provider();

        let manager = DirectoryPowerPreferencesManager {
            root: root.path().to_path_buf(),
            config_provider,
            power_source_provider,
        };

        manager
            .update_power_preferences(
                common::RTCAudioActive::Active,
                common::FullscreenVideo::Inactive,
                common::GameMode::Off,
                common::VmBootMode::Inactive,
                common::BatterySaverMode::Inactive,
            )
            .unwrap();

        let powersave_bias = read_global_powersave_bias(root.path()).unwrap();
        assert_eq!(powersave_bias, "200");

        let sampling_rate = read_global_sampling_rate(root.path()).unwrap();
        assert_eq!(sampling_rate, "4000");
    }

    #[test]
    fn test_power_update_power_preferences_rtc_active() {
        let root = tempdir().unwrap();

        write_global_powersave_bias(root.path(), 0).unwrap();
        write_global_sampling_rate(root.path(), 2000).unwrap();
        test_write_cpuset_root_cpus(root.path(), "0-3");

        let power_source_provider = FakePowerSourceProvider {
            power_source: PowerSourceType::AC,
        };

        let mut fake_config = FakeConfig::new();
        fake_config.write_power_preference(
            PowerSourceType::AC,
            PowerPreferencesType::WebRTC,
            &PowerPreferences {
                governor: Some(Governor::Ondemand {
                    powersave_bias: 200,
                    sampling_rate: Some(16000),
                }),
                epp: None,
                cpu_offline: None,
                cpufreq_disable_boost: false,
            },
        );
        let config_provider = fake_config.provider();

        let manager = DirectoryPowerPreferencesManager {
            root: root.path().to_path_buf(),
            config_provider,
            power_source_provider,
        };

        manager
            .update_power_preferences(
                common::RTCAudioActive::Active,
                common::FullscreenVideo::Inactive,
                common::GameMode::Off,
                common::VmBootMode::Inactive,
                common::BatterySaverMode::Inactive,
            )
            .unwrap();

        let powersave_bias = read_global_powersave_bias(root.path()).unwrap();
        assert_eq!(powersave_bias, "200");

        let sampling_rate = read_global_sampling_rate(root.path()).unwrap();
        assert_eq!(sampling_rate, "16000");
    }

    /// Tests default battery saver mode
    #[test]
    fn test_apply_hotplug_cpus() {
        struct Test<'a> {
            cpus: &'a str,
            big_little: bool,
            cluster1_state: [&'a str; 2],
            cluster2_state: [&'a str; 2],
            cluster1_freq: [u32; 2],
            cluster2_freq: [u32; 2],
            preferences: PowerPreferences,
            smt_offlined: bool,
            smt_orig_state: &'a str,
            cluster1_expected_state: [&'a str; 2],
            cluster2_expected_state: [&'a str; 2],
            smt_expected_state: &'a str,
        }

        let tests = [
            // Test offline small core
            Test {
                cpus: "0-3",
                big_little: true,
                cluster1_state: ["1"; 2],
                cluster2_state: ["1"; 2],
                cluster1_freq: [2400000; 2],
                cluster2_freq: [1800000; 2],
                preferences: PowerPreferences {
                    governor: Some(Governor::Conservative),
                    epp: None,
                    cpu_offline: Some(CpuOfflinePreference::SmallCore {
                        min_active_threads: 2,
                    }),
                    cpufreq_disable_boost: false,
                },
                smt_offlined: false,
                smt_orig_state: "on",
                cluster1_expected_state: ["1"; 2],
                cluster2_expected_state: ["0"; 2],
                smt_expected_state: "",
            },
            // Test offline SMT
            Test {
                cpus: "0-3",
                big_little: false,
                cluster1_state: ["1"; 2],
                cluster2_state: ["1"; 2],
                cluster1_freq: [2400000; 2],
                cluster2_freq: [2400000; 2],
                preferences: PowerPreferences {
                    governor: None,
                    epp: None,
                    cpu_offline: Some(CpuOfflinePreference::Smt {
                        min_active_threads: 2,
                    }),
                    cpufreq_disable_boost: false,
                },
                smt_offlined: true,
                smt_orig_state: "on",
                cluster1_expected_state: ["1"; 2],
                cluster2_expected_state: ["0"; 2],
                smt_expected_state: "off",
            },
            // Test offline half
            Test {
                cpus: "0-3",
                big_little: false,
                cluster1_state: ["1"; 2],
                cluster2_state: ["1"; 2],
                cluster1_freq: [2400000; 2],
                cluster2_freq: [2400000; 2],
                preferences: PowerPreferences {
                    governor: Some(Governor::Conservative),
                    epp: None,
                    cpu_offline: Some(CpuOfflinePreference::Half {
                        min_active_threads: 2,
                    }),
                    cpufreq_disable_boost: false,
                },
                smt_offlined: false,
                smt_orig_state: "on",
                cluster1_expected_state: ["1"; 2],
                cluster2_expected_state: ["0"; 2],
                smt_expected_state: "off",
            },
            // Test online all
            Test {
                cpus: "0-3",
                big_little: false,
                cluster1_state: ["1"; 2],
                cluster2_state: ["0"; 2],
                cluster1_freq: [2400000; 2],
                cluster2_freq: [2400000; 2],
                preferences: PowerPreferences {
                    governor: None,
                    epp: None,
                    cpu_offline: None,
                    cpufreq_disable_boost: false,
                },
                smt_offlined: false,
                smt_orig_state: "on",
                cluster1_expected_state: ["1"; 2],
                cluster2_expected_state: ["1"; 2],
                smt_expected_state: "off",
            },
        ];

        for test in tests {
            //Setup
            let temp_dir = tempdir().unwrap();
            let root = temp_dir.path();
            let fake_config = FakeConfig::new();
            let config_provider = fake_config.provider();
            let manager = DirectoryPowerPreferencesManager {
                root: root.to_path_buf(),
                config_provider,
                power_source_provider: FakePowerSourceProvider {
                    power_source: PowerSourceType::DC,
                },
            };
            test_write_cpuset_root_cpus(root, test.cpus);
            test_write_smt_control(root, test.smt_orig_state);
            // Setup core cpus list for two physical cores and two virtual cores
            test_write_core_cpus_list(root, 0, "0,2");
            test_write_core_cpus_list(root, 1, "1,3");
            test_write_core_cpus_list(root, 2, "0,2");
            test_write_core_cpus_list(root, 3, "1,3");

            if test.big_little {
                test_write_ui_use_flags(root, "big_little");
            }

            for (i, freq) in test.cluster1_freq.iter().enumerate() {
                test_write_online_cpu(root, i.try_into().unwrap(), test.cluster1_state[i]);
                test_write_cpu_max_freq(root, i.try_into().unwrap(), *freq);
            }
            for (i, freq) in test.cluster2_freq.iter().enumerate() {
                test_write_online_cpu(
                    root,
                    (test.cluster1_freq.len() + i).try_into().unwrap(),
                    test.cluster2_state[i],
                );
                test_write_cpu_max_freq(
                    root,
                    (test.cluster1_freq.len() + i).try_into().unwrap(),
                    *freq,
                );
            }

            // Call function to test
            manager.apply_cpu_hotplug(test.preferences).unwrap();

            // Check result.
            if test.smt_offlined {
                // The mock sysfs cannot offline the SMT CPUs, here to check the smt control state
                test_check_smt_control(root, test.smt_expected_state);
                continue;
            }

            for (i, state) in test.cluster1_expected_state.iter().enumerate() {
                test_check_online_cpu(root, i.try_into().unwrap(), state);
            }

            for (i, state) in test.cluster2_expected_state.iter().enumerate() {
                test_check_online_cpu(
                    root,
                    (test.cluster1_expected_state.len() + i).try_into().unwrap(),
                    state,
                );
            }
        }
    }

    #[test]
    fn test_power_update_power_preferences_fullscreen_active() {
        let root = tempdir().unwrap();

        write_global_powersave_bias(root.path(), 0).unwrap();
        write_global_sampling_rate(root.path(), 2000).unwrap();
        test_write_cpuset_root_cpus(root.path(), "0-3");

        let power_source_provider = FakePowerSourceProvider {
            power_source: PowerSourceType::AC,
        };

        let mut fake_config = FakeConfig::new();
        fake_config.write_power_preference(
            PowerSourceType::AC,
            PowerPreferencesType::Fullscreen,
            &PowerPreferences {
                governor: Some(Governor::Ondemand {
                    powersave_bias: 200,
                    sampling_rate: Some(16000),
                }),
                epp: None,
                cpu_offline: None,
                cpufreq_disable_boost: false,
            },
        );
        let config_provider = fake_config.provider();

        let manager = DirectoryPowerPreferencesManager {
            root: root.path().to_path_buf(),
            config_provider,
            power_source_provider,
        };

        manager
            .update_power_preferences(
                common::RTCAudioActive::Inactive,
                common::FullscreenVideo::Active,
                common::GameMode::Off,
                common::VmBootMode::Inactive,
                common::BatterySaverMode::Inactive,
            )
            .unwrap();

        let powersave_bias = read_global_powersave_bias(root.path()).unwrap();
        assert_eq!(powersave_bias, "200");

        let sampling_rate = read_global_sampling_rate(root.path()).unwrap();
        assert_eq!(sampling_rate, "16000");
    }

    #[test]
    fn test_power_update_power_preferences_borealis_gaming_active() {
        let root = tempdir().unwrap();

        write_global_powersave_bias(root.path(), 0).unwrap();
        write_global_sampling_rate(root.path(), 2000).unwrap();
        test_write_cpuset_root_cpus(root.path(), "0-3");

        let power_source_provider = FakePowerSourceProvider {
            power_source: PowerSourceType::AC,
        };

        let mut fake_config = FakeConfig::new();
        fake_config.write_power_preference(
            PowerSourceType::AC,
            PowerPreferencesType::BorealisGaming,
            &PowerPreferences {
                governor: Some(Governor::Ondemand {
                    powersave_bias: 200,
                    sampling_rate: Some(16000),
                }),
                epp: None,
                cpu_offline: None,
                cpufreq_disable_boost: false,
            },
        );
        let config_provider = fake_config.provider();

        let manager = DirectoryPowerPreferencesManager {
            root: root.path().to_path_buf(),
            config_provider,
            power_source_provider,
        };

        manager
            .update_power_preferences(
                common::RTCAudioActive::Inactive,
                common::FullscreenVideo::Inactive,
                common::GameMode::Borealis,
                common::VmBootMode::Inactive,
                common::BatterySaverMode::Inactive,
            )
            .unwrap();

        let powersave_bias = read_global_powersave_bias(root.path()).unwrap();
        assert_eq!(powersave_bias, "200");

        let sampling_rate = read_global_sampling_rate(root.path()).unwrap();
        assert_eq!(sampling_rate, "16000");
    }

    #[test]
    fn test_power_update_power_preferences_arcvm_gaming_active() {
        let root = tempdir().unwrap();

        write_global_powersave_bias(root.path(), 0).unwrap();
        write_global_sampling_rate(root.path(), 2000).unwrap();
        test_write_cpuset_root_cpus(root.path(), "0-3");

        let power_source_provider = FakePowerSourceProvider {
            power_source: PowerSourceType::AC,
        };

        let mut fake_config = FakeConfig::new();
        fake_config.write_power_preference(
            PowerSourceType::AC,
            PowerPreferencesType::ArcvmGaming,
            &PowerPreferences {
                governor: Some(Governor::Ondemand {
                    powersave_bias: 200,
                    sampling_rate: Some(16000),
                }),
                epp: None,
                cpu_offline: None,
                cpufreq_disable_boost: false,
            },
        );
        let config_provider = fake_config.provider();

        let manager = DirectoryPowerPreferencesManager {
            root: root.path().to_path_buf(),
            config_provider,
            power_source_provider,
        };
        manager
            .update_power_preferences(
                common::RTCAudioActive::Inactive,
                common::FullscreenVideo::Inactive,
                common::GameMode::Arc,
                common::VmBootMode::Inactive,
                common::BatterySaverMode::Inactive,
            )
            .unwrap();

        let powersave_bias = read_global_powersave_bias(root.path()).unwrap();
        assert_eq!(powersave_bias, "200");

        let sampling_rate = read_global_sampling_rate(root.path()).unwrap();
        assert_eq!(sampling_rate, "16000");
    }

    #[test]
    fn test_per_policy_ondemand_governor() {
        let temp_dir = tempdir().unwrap();
        let root = temp_dir.path();

        const INIT_POWERSAVE_BIAS: u32 = 0;
        const INIT_SAMPLING_RATE: u32 = 2000;
        const CONFIG_POWERSAVE_BIAS: u32 = 200;
        const CONFIG_SAMPLING_RATE: u32 = 16000;

        let ondemand = Governor::Ondemand {
            powersave_bias: INIT_POWERSAVE_BIAS,
            sampling_rate: Some(INIT_SAMPLING_RATE),
        };
        let policy0 = PolicyConfigs {
            policy_path: TEST_CPUFREQ_POLICIES[0],
            governor: &ondemand,
            affected_cpus: "0",
        };
        let policy1 = PolicyConfigs {
            policy_path: TEST_CPUFREQ_POLICIES[1],
            governor: &ondemand,
            affected_cpus: "1",
        };
        let policies = vec![policy0, policy1];
        write_per_policy_scaling_governor(root, policies);
        write_per_policy_powersave_bias(root, INIT_POWERSAVE_BIAS);
        write_per_policy_sampling_rate(root, INIT_SAMPLING_RATE);
        test_write_cpuset_root_cpus(root, "0-3");

        let power_source_provider = FakePowerSourceProvider {
            power_source: PowerSourceType::AC,
        };

        let mut fake_config = FakeConfig::new();
        fake_config.write_power_preference(
            PowerSourceType::AC,
            PowerPreferencesType::ArcvmGaming,
            &PowerPreferences {
                governor: Some(Governor::Ondemand {
                    powersave_bias: CONFIG_POWERSAVE_BIAS,
                    sampling_rate: Some(CONFIG_SAMPLING_RATE),
                }),
                epp: None,
                cpu_offline: None,
                cpufreq_disable_boost: false,
            },
        );
        let config_provider = fake_config.provider();

        let manager = DirectoryPowerPreferencesManager {
            root: root.to_path_buf(),
            config_provider,
            power_source_provider,
        };
        manager
            .update_power_preferences(
                common::RTCAudioActive::Inactive,
                common::FullscreenVideo::Inactive,
                common::GameMode::Arc,
                common::VmBootMode::Inactive,
                common::BatterySaverMode::Inactive,
            )
            .unwrap();
        check_per_policy_scaling_governor(root, vec![ondemand, ondemand]);
        check_per_policy_powersave_bias(root, CONFIG_POWERSAVE_BIAS);
        check_per_policy_sampling_rate(root, CONFIG_SAMPLING_RATE);
    }

    #[test]
    fn test_scaling_governors() {
        let temp_dir = tempdir().unwrap();
        let root = temp_dir.path();

        test_write_cpuset_root_cpus(root, "0-3");
        const INIT_POWERSAVE_BIAS: u32 = 0;
        const INIT_SAMPLING_RATE: u32 = 2000;

        let ondemand = Governor::Ondemand {
            powersave_bias: INIT_POWERSAVE_BIAS,
            sampling_rate: Some(INIT_SAMPLING_RATE),
        };
        let policy0 = PolicyConfigs {
            policy_path: TEST_CPUFREQ_POLICIES[0],
            governor: &ondemand,
            affected_cpus: AFFECTED_CPU0,
        };
        let policy1 = PolicyConfigs {
            policy_path: TEST_CPUFREQ_POLICIES[1],
            governor: &ondemand,
            affected_cpus: AFFECTED_CPU1,
        };
        let policies = vec![policy0, policy1];
        write_per_policy_scaling_governor(root, policies);

        let governors = [
            Governor::Conservative,
            Governor::Performance,
            Governor::Powersave,
            Governor::Schedutil,
            Governor::Userspace,
        ];

        for governor in governors {
            let power_source_provider = FakePowerSourceProvider {
                power_source: PowerSourceType::AC,
            };
            let mut fake_config = FakeConfig::new();
            fake_config.write_power_preference(
                PowerSourceType::AC,
                PowerPreferencesType::ArcvmGaming,
                &PowerPreferences {
                    governor: Some(governor),
                    epp: None,
                    cpu_offline: None,
                    cpufreq_disable_boost: false,
                },
            );
            let config_provider = fake_config.provider();
            let manager = DirectoryPowerPreferencesManager {
                root: root.to_path_buf(),
                config_provider,
                power_source_provider,
            };

            manager
                .update_power_preferences(
                    common::RTCAudioActive::Inactive,
                    common::FullscreenVideo::Inactive,
                    common::GameMode::Arc,
                    common::VmBootMode::Inactive,
                    common::BatterySaverMode::Inactive,
                )
                .unwrap();

            check_per_policy_scaling_governor(root, vec![governor, governor]);
        }
    }
}