Add support for platform profile

Author: qzed

src/cli/mod.rs

@@ -1,6 +1,7 @@
 pub mod dgpu;
 pub mod dtx;
 pub mod perf;
+pub mod profile;
 pub mod status;
 
 use anyhow::Result;
@@ -24,6 +25,7 @@ impl Registry {
         let list: Vec<Box<dyn Command>> = vec![
             Box::new(status::Command),
             Box::new(perf::Command),
+            Box::new(profile::Command),
             Box::new(dtx::Command),
             Box::new(dgpu::Command),
         ];

src/cli/profile.rs

@@ -0,0 +1,105 @@
+use crate::cli::Command as DynCommand;
+use crate::sys;
+
+use anyhow::{Context, Result};
+
+
+pub struct Command;
+
+impl DynCommand for Command {
+    fn name(&self) -> &'static str {
+        "profile"
+    }
+
+    fn build(&self) -> clap::App<'static, 'static> {
+        use clap::{AppSettings, Arg, SubCommand};
+
+        SubCommand::with_name(self.name())
+            .about("Control or query the current platform profile")
+            .setting(AppSettings::SubcommandRequiredElseHelp)
+            .subcommand(SubCommand::with_name("set")
+                .about("Set the current platform profile")
+                .arg(Arg::with_name("profile")
+                    .required(true)
+                    .index(1)))
+            .subcommand(SubCommand::with_name("get")
+                .about("Get the current platform profile"))
+            .subcommand(SubCommand::with_name("list")
+                .about("List all available platform profiles"))
+    }
+
+    fn execute(&self, m: &clap::ArgMatches) -> Result<()> {
+        match m.subcommand() {
+            ("set", Some(m))  => self.profile_set(m),
+            ("get", Some(m))  => self.profile_get(m),
+            ("list", Some(m)) => self.profile_list(m),
+            _                => unreachable!(),
+        }
+    }
+}
+
+impl Command {
+    fn profile_set(&self, m: &clap::ArgMatches) -> Result<()> {
+        let profile = m.value_of("profile").unwrap();
+
+        let dev = sys::profile::Device::open()
+            .context("Failed to open platform profile device")?;
+
+        let supported = dev.get_supported()
+            .context("Failed to get supported platform profiles")?;
+
+        if !supported.iter().any(|p| p == profile) {
+            anyhow::bail!("Platform profile '{}' is not supported", profile);
+        }
+
+        let current_profile = dev.get()
+            .context("Failed to get current platform profile")?;
+
+        if profile != current_profile {
+            dev.set(profile)
+                .context("Failed to set platform profile")?;
+
+            if !m.is_present("quiet") {
+                println!("Platform profile set to '{}'", profile);
+            }
+
+        } else if !m.is_present("quiet") {
+            println!("Platform profile already set to '{}', not changing", profile);
+        }
+
+        Ok(())
+    }
+
+    fn profile_get(&self, _m: &clap::ArgMatches) -> Result<()> {
+        let dev = sys::profile::Device::open()
+            .context("Failed to open platform profile device")?;
+
+        let profile = dev.get()
+            .context("Failed to get current platform profile")?;
+
+        println!("{}", profile);
+        Ok(())
+    }
+
+    fn profile_list(&self, m: &clap::ArgMatches) -> Result<()> {
+        let dev = sys::profile::Device::open()
+            .context("Failed to open platform profile device")?;
+
+        let supported = dev.get_supported()
+            .context("Failed to get supported platform profiles")?;
+
+        if !m.is_present("quiet") {
+            for profile in supported {
+                println!("{}", profile);
+            }
+
+        } else {
+            let text = serde_json::to_string(&supported)
+                .context("Failed to serialize data")?;
+
+            println!("{}", text);
+        }
+
+        Ok(())
+    }
+}

src/sys/mod.rs

@@ -1,5 +1,6 @@
 pub mod pci;
 pub mod perf;
+pub mod profile;
 
 use thiserror::Error;
 

src/sys/profile.rs

@@ -0,0 +1,89 @@
+use std::{fs::OpenOptions, io::{Read, Write}};
+use std::path::{Path, PathBuf};
+
+use crate::sys::{Error, Result};
+
+
+pub struct Device {
+    path: PathBuf,
+}
+
+impl Device {
+    pub fn open() -> Result<Self> {
+        Device::open_path("/sys/firmware/acpi/")
+    }
+
+    pub fn open_path<P: AsRef<Path>>(path: P) -> Result<Self> {
+        use std::io;
+
+        if path.as_ref().is_dir() && path.as_ref().join("platform_profile").is_file()
+            && path.as_ref().join("platform_profile_choices").is_file()
+        {
+            Ok(Device {
+                path: path.as_ref().to_owned(),
+            })
+        } else {
+            Err(Error::DeviceAccess {
+                source: io::Error::new(io::ErrorKind::NotFound, "No platform profile support found"),
+                device: path.as_ref().to_owned(),
+            })
+        }
+    }
+
+    pub fn get(&self) -> Result<String> {
+        let attribute = "platform_profile";
+
+        let mut file = OpenOptions::new()
+            .read(true)
+            .open(self.path.as_path().join(attribute))
+            .map_err(|source| Error::DeviceAccess {
+                source,
+                device: self.path.as_path().join(attribute),
+            })?;
+
+        let mut profile = String::new();
+        file.read_to_string(&mut profile)
+            .map_err(|e| Error::IoError { source: e })?;
+
+        Ok(profile.trim().to_owned())
+    }
+
+    pub fn set(&self, profile: &str) -> Result<()> {
+        let attribute = "platform_profile";
+
+        let mut file = OpenOptions::new()
+            .write(true)
+            .open(self.path.as_path().join(attribute))
+            .map_err(|source| Error::DeviceAccess {
+                source,
+                device: self.path.as_path().join(attribute),
+            })?;
+
+        file.write(profile.as_bytes())
+            .map_err(|e| Error::IoError { source: e })?;
+
+        Ok(())
+    }
+
+    pub fn get_supported(&self) -> Result<Vec<String>> {
+        let attribute = "platform_profile_choices";
+
+        let mut file = OpenOptions::new()
+            .read(true)
+            .open(self.path.as_path().join(attribute))
+            .map_err(|source| Error::DeviceAccess {
+                source,
+                device: self.path.as_path().join(attribute),
+            })?;
+
+        let mut supported = String::new();
+        file.read_to_string(&mut supported)
+            .map_err(|e| Error::IoError { source: e })?;
+
+        let supported = supported.split_ascii_whitespace()
+            .map(|s| s.trim().to_owned())
+            .collect();
+
+        Ok(supported)
+    }
+}