chore: wip

Author: not-matthias

src/run/runner/helpers/isolation.rs

@@ -1,5 +1,110 @@
+use std::io::Write;
+
+use anyhow::Context;
+use itertools::Itertools;
+
 use super::setup::run_with_sudo;
 
+pub struct IrqIsolation {
+    default_affinity: String,
+    irq_affinity: Vec<(u32, String)>,
+}
+
+const DEFAULT_AFFINITY_PATH: &str = "/proc/irq/default_smp_affinity";
+
+impl IrqIsolation {
+    fn irq_smp_affinity_path(irq: u32) -> String {
+        format!("/proc/irq/{irq}/smp_affinity")
+    }
+
+    /// Read from a virtual file and chomp away the trailing newline.
+    fn read_vfile(path: &str) -> anyhow::Result<String> {
+        let mut s =
+            std::fs::read_to_string(path).with_context(|| format!("failed to read {path}"))?;
+        if s.ends_with('\n') {
+            s.pop();
+        }
+        Ok(s)
+    }
+
+    /// Write to a virtual file within a single syscall.
+    fn write_vfile(path: &str, content: &str) -> anyhow::Result<()> {
+        std::fs::File::options()
+            .write(true)
+            .open(path)
+            .map_err(Into::into)
+            .and_then(|mut f| match f.write(content.as_bytes()) {
+                Ok(n) if n == content.len() => Ok(()),
+                Ok(n) => anyhow::bail!("partial write of {n} bytes"),
+                Err(err) => Err(err.into()),
+            })
+            .with_context(|| format!("failed to write {content:?} to {path}"))
+    }
+
+    pub fn new() -> anyhow::Result<Self> {
+        let default_affinity = Self::read_vfile(DEFAULT_AFFINITY_PATH)?;
+
+        let mut irq_affinity = Vec::new();
+        for ent in std::fs::read_dir("/proc/irq")?.filter_map(Result::ok) {
+            if !ent.file_type()?.is_dir() {
+                continue;
+            }
+            let Some(irq) = ent.file_name().to_str().and_then(|s| s.parse::<u32>().ok()) else {
+                continue;
+            };
+
+            irq_affinity.push((irq, Self::read_vfile(&Self::irq_smp_affinity_path(irq))?));
+        }
+        irq_affinity.sort_unstable_by_key(|(irq, ..)| *irq);
+
+        Ok(Self {
+            default_affinity,
+            irq_affinity,
+        })
+    }
+
+    pub fn isolate(&self, allowed_cpus: &[u32]) -> anyhow::Result<()> {
+        let convert_mask = |mask: &str| {
+            let mut masks = mask
+                .split(',')
+                .map(|seg| u32::from_str_radix(seg, 16))
+                .collect::<Result<Vec<_>, _>>()?;
+
+            let mut changed = false;
+            for &cpu in allowed_cpus {
+                let (idx, bit) = (cpu as usize / 32, 1u32 << (cpu % 32));
+                if masks[idx] & bit != 0 {
+                    changed = true;
+                    masks[idx] ^= bit;
+                }
+            }
+
+            // Skip uneffected IRQs.
+            if !changed {
+                return Ok(None);
+            }
+
+            // Do not leave it empty, it would be invalid. CPU 0 must not be used by us.
+            if masks.iter().all(|&m| m == 0) {
+                masks[0] = 1;
+            }
+
+            let new_masks = masks
+                .iter()
+                .format_with(",", |&m, f| f(&format_args!("{m:x}")))
+                .to_string();
+            Ok(Some(new_masks))
+        };
+
+        if let Some(mask) = &self.default_affinity {
+            // convert_mask(value)?
+            // Self::write_vfile(DEFAULT_AFFINITY_PATH, )?;
+        }
+
+        for (irq, _, new_masks) in &self.irq_affinity {}
+    }
+}
+
 pub struct CpuIsolation {
     nproc: u32,
 }
@@ -53,6 +158,10 @@ impl CpuIsolation {
 
         Ok(())
     }
+
+    pub fn isolate_irqs(&self) -> anyhow::Result<()> {
+        Ok(())
+    }
 }
 
 impl Drop for CpuIsolation {