use std::fmt;
const RESCTRL: &str = "/sys/fs/resctrl";
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CatCapability {
pub supported: bool,
pub num_closids: u32,
pub cbm_bits: u32,
pub min_cbm_bits: u32,
pub num_domains: u32,
}
impl CatCapability {
pub fn detect() -> Self {
let unsupported = Self {
supported: false,
num_closids: 0,
cbm_bits: 0,
min_cbm_bits: 0,
num_domains: 0,
};
let info = format!("{RESCTRL}/info/L3");
if !std::path::Path::new(&info).is_dir() {
return unsupported;
}
let read_u32 = |name: &str| -> u32 {
std::fs::read_to_string(format!("{info}/{name}"))
.ok()
.and_then(|s| s.trim().parse::<u32>().ok())
.unwrap_or(0)
};
let cbm_bits = std::fs::read_to_string(format!("{info}/cbm_mask"))
.ok()
.and_then(|s| parse_cbm_mask_hex(s.trim()))
.map(count_ways)
.unwrap_or(0);
let num_domains = std::fs::read_to_string(format!("{RESCTRL}/schemata"))
.ok()
.map(|s| count_l3_domains(&s))
.unwrap_or(0);
Self {
supported: cbm_bits > 0,
num_closids: read_u32("num_closids"),
cbm_bits,
min_cbm_bits: read_u32("min_cbm_bits").max(1),
num_domains: num_domains.max(1),
}
}
}
#[derive(Debug)]
pub enum CatError {
Unsupported,
InvalidRange {
first_way: u32,
num_ways: u32,
total_ways: u32,
},
Io(std::io::Error),
}
impl fmt::Display for CatError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Unsupported => write!(f, "resctrl / L3 CAT unavailable on this host"),
Self::InvalidRange { first_way, num_ways, total_ways } => write!(
f,
"way range [{first_way}, {}) exceeds {total_ways} L3 ways",
first_way + num_ways
),
Self::Io(e) => write!(f, "resctrl I/O: {e}"),
}
}
}
impl std::error::Error for CatError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::Io(e) => Some(e),
_ => None,
}
}
}
pub struct L3Reservation {
dir: std::path::PathBuf,
}
impl L3Reservation {
pub fn reserve_ways(name: &str, first_way: u32, num_ways: u32) -> Result<Self, CatError> {
let cap = CatCapability::detect();
if !cap.supported {
return Err(CatError::Unsupported);
}
if num_ways == 0 || first_way + num_ways > cap.cbm_bits {
return Err(CatError::InvalidRange {
first_way,
num_ways,
total_ways: cap.cbm_bits,
});
}
let mask = contiguous_mask(first_way, num_ways);
let dir = std::path::PathBuf::from(format!("{RESCTRL}/{name}"));
std::fs::create_dir_all(&dir).map_err(CatError::Io)?;
let current = std::fs::read_to_string(dir.join("schemata")).map_err(CatError::Io)?;
let line = rewrite_l3_schemata(¤t, mask);
std::fs::write(dir.join("schemata"), line.as_bytes()).map_err(CatError::Io)?;
let pid = std::process::id();
std::fs::write(dir.join("tasks"), format!("{pid}\n").as_bytes()).map_err(CatError::Io)?;
Ok(Self { dir })
}
pub fn schemata(&self) -> Result<String, CatError> {
std::fs::read_to_string(self.dir.join("schemata")).map_err(CatError::Io)
}
}
impl Drop for L3Reservation {
fn drop(&mut self) {
drop(std::fs::remove_dir(&self.dir));
}
}
fn contiguous_mask(first_way: u32, num_ways: u32) -> u64 {
if num_ways == 0 {
return 0;
}
let width = num_ways.min(64);
let base = if width == 64 { u64::MAX } else { (1u64 << width) - 1 };
base << first_way
}
fn count_ways(mask: u64) -> u32 {
mask.count_ones()
}
fn parse_cbm_mask_hex(s: &str) -> Option<u64> {
let t = s.trim().trim_start_matches("0x");
if t.is_empty() {
return None;
}
u64::from_str_radix(t, 16).ok()
}
fn count_l3_domains(schemata: &str) -> u32 {
for line in schemata.lines() {
let line = line.trim();
if let Some(rest) = line.strip_prefix("L3:") {
return rest.split(';').filter(|p| p.contains('=')).count() as u32;
}
}
0
}
fn rewrite_l3_schemata(schemata: &str, mask: u64) -> String {
let mut out = String::new();
for line in schemata.lines() {
let trimmed = line.trim();
if let Some(rest) = trimmed.strip_prefix("L3:") {
let pairs: Vec<String> = rest
.split(';')
.filter_map(|p| p.split('=').next())
.map(|dom| format!("{}={:x}", dom.trim(), mask))
.collect();
out.push_str("L3:");
out.push_str(&pairs.join(";"));
out.push('\n');
} else if !trimmed.is_empty() {
out.push_str(line);
out.push('\n');
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn contiguous_mask_places_the_right_ways() {
assert_eq!(contiguous_mask(0, 4), 0x0f);
assert_eq!(contiguous_mask(4, 4), 0xf0);
assert_eq!(contiguous_mask(0, 1), 0x1);
assert_eq!(contiguous_mask(0, 0), 0x0);
assert_eq!(count_ways(contiguous_mask(2, 6)), 6);
}
#[test]
fn cbm_mask_hex_parses() {
assert_eq!(parse_cbm_mask_hex("7fff"), Some(0x7fff));
assert_eq!(parse_cbm_mask_hex("0xff"), Some(0xff));
assert_eq!(count_ways(0x7fff), 15);
assert_eq!(parse_cbm_mask_hex(""), None);
}
#[test]
fn domain_counting() {
assert_eq!(count_l3_domains("L3:0=7fff;1=7fff\nMB:0=100;1=100\n"), 2);
assert_eq!(count_l3_domains("L3:0=ffff\n"), 1);
assert_eq!(count_l3_domains("MB:0=100\n"), 0);
}
#[test]
fn schemata_rewrite_preserves_domains() {
let before = "L3:0=7fff;1=7fff\nMB:0=100;1=100\n";
let after = rewrite_l3_schemata(before, 0x00f0);
assert!(after.contains("L3:0=f0;1=f0"), "got: {after}");
assert!(after.contains("MB:0=100;1=100"));
}
#[test]
fn detect_is_unsupported_off_linux_or_unmounted() {
let cap = CatCapability::detect();
if cfg!(not(target_os = "linux")) {
assert!(!cap.supported, "resctrl cannot exist off Linux");
assert_eq!(cap.cbm_bits, 0);
}
}
#[test]
fn reserve_is_unsupported_when_capability_absent() {
if !CatCapability::detect().supported {
assert!(matches!(
L3Reservation::reserve_ways("flynnel_test", 0, 4),
Err(CatError::Unsupported)
));
}
}
}