use super::{sudo_command, sudo_failure, verify_sudo_available};
use crate::error::{IronError, Result};
use std::fs;
use std::path::Path;
use std::process::Command;
const JETSON_CLOCKS_PATHS: &[&str] = &["/usr/bin/jetson_clocks", "/home/nvidia/jetson_clocks.sh"];
#[derive(Debug, Clone)]
pub struct JetsonClocksStatus {
pub active: bool,
pub engines: Vec<String>,
}
pub fn is_available() -> bool {
JETSON_CLOCKS_PATHS.iter().any(|p| Path::new(p).exists())
}
fn find_jetson_clocks() -> Result<String> {
JETSON_CLOCKS_PATHS
.iter()
.find(|p| Path::new(p).exists())
.map(|s| s.to_string())
.ok_or_else(|| IronError::DeviceNotFound("jetson_clocks not found".to_string()))
}
pub fn enable() -> Result<()> {
verify_sudo_available()?;
let jetson_clocks = find_jetson_clocks()?;
let output = sudo_command()
.arg(&jetson_clocks)
.output()
.map_err(IronError::Io)?;
if !output.status.success() {
return Err(sudo_failure(&output, "enable jetson_clocks"));
}
Ok(())
}
pub fn disable() -> Result<()> {
verify_sudo_available()?;
let jetson_clocks = find_jetson_clocks()?;
let output = sudo_command()
.arg(&jetson_clocks)
.arg("--restore")
.output()
.map_err(IronError::Io)?;
if !output.status.success() {
return Err(sudo_failure(&output, "disable jetson_clocks"));
}
Ok(())
}
pub fn show() -> Result<JetsonClocksStatus> {
let jetson_clocks = find_jetson_clocks()?;
let output = Command::new(&jetson_clocks)
.arg("--show")
.output()
.map_err(IronError::Io)?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
return Err(IronError::CommandFailed(format!(
"Failed to get jetson_clocks status: {}",
stderr
)));
}
let stdout = String::from_utf8_lossy(&output.stdout);
let engines: Vec<String> = stdout
.lines()
.filter(|line| line.contains("MaxFreq="))
.map(|line| {
line.split_whitespace()
.next()
.unwrap_or("unknown")
.to_string()
})
.collect();
let active = check_if_active()?;
Ok(JetsonClocksStatus { active, engines })
}
fn check_if_active() -> Result<bool> {
if let Ok(cpu_online) = fs::read_to_string("/sys/devices/system/cpu/online") {
for cpu_range in cpu_online.trim().split(',') {
if let Some((start, end)) = parse_cpu_range(cpu_range) {
for cpu in start..=end {
let min_path = format!(
"/sys/devices/system/cpu/cpu{}/cpufreq/scaling_min_freq",
cpu
);
let max_path = format!(
"/sys/devices/system/cpu/cpu{}/cpufreq/scaling_max_freq",
cpu
);
if let (Ok(min), Ok(max)) =
(fs::read_to_string(&min_path), fs::read_to_string(&max_path))
{
let min_freq: u32 = min.trim().parse().unwrap_or(0);
let max_freq: u32 = max.trim().parse().unwrap_or(0);
if min_freq != max_freq {
return Ok(false);
}
}
}
}
}
}
Ok(true)
}
fn parse_cpu_range(range: &str) -> Option<(u32, u32)> {
if range.contains('-') {
let parts: Vec<&str> = range.split('-').collect();
if parts.len() == 2 {
let start = parts[0].parse().ok()?;
let end = parts[1].parse().ok()?;
return Some((start, end));
}
} else {
let cpu = range.parse().ok()?;
return Some((cpu, cpu));
}
None
}
pub fn store() -> Result<()> {
verify_sudo_available()?;
let jetson_clocks = find_jetson_clocks()?;
let output = sudo_command()
.arg(&jetson_clocks)
.arg("--store")
.output()
.map_err(IronError::Io)?;
if !output.status.success() {
return Err(sudo_failure(&output, "store jetson_clocks config"));
}
Ok(())
}