use std::collections::BTreeMap;
use crate::types::DetPid;
use crate::types::DetTid;
pub type PidNamespace = Option<DetPid>;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum PidNamespaceRecordError {
Wrapped {
namespace: DetPid,
pid: i32,
highest: i32,
},
Mismatch(String),
}
impl std::fmt::Display for PidNamespaceRecordError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
PidNamespaceRecordError::Wrapped {
namespace,
pid,
highest,
} => write!(
f,
"the PID namespace of init {namespace} handed out pid {pid} after {highest}: its allocator wrapped, and which pids were free depends on host reap timing"
),
PidNamespaceRecordError::Mismatch(detail) => write!(f, "{detail}"),
}
}
}
#[derive(Debug, Default, Clone)]
pub struct PidNamespaces {
levels: BTreeMap<DetTid, Vec<(DetPid, i32)>>,
tasks: BTreeMap<(DetPid, i32), DetTid>,
highest: BTreeMap<DetPid, i32>,
untranslatable: BTreeMap<DetTid, String>,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum GuestPidAnswer {
Task {
task: DetTid,
own_init_caught: Option<u64>,
},
NoSuchPid,
Untranslatable(String),
}
impl PidNamespaces {
pub fn namespace_of(&self, task: DetTid) -> PidNamespace {
self.levels
.get(&task)
.and_then(|levels| levels.last())
.map(|(init, _)| *init)
}
pub fn chain_of(&self, task: DetTid) -> Vec<DetPid> {
self.levels
.get(&task)
.map(|levels| levels.iter().map(|(init, _)| *init).collect())
.unwrap_or_default()
}
pub fn record(
&mut self,
task: DetTid,
chain: &[DetPid],
nspid: &[i32],
) -> Result<(), PidNamespaceRecordError> {
if nspid.len() != chain.len() + 1 || nspid.first() != Some(&task.as_raw()) {
return Err(PidNamespaceRecordError::Mismatch(format!(
"task {} has NSpid {:?} for namespace chain {:?}",
task, nspid, chain
)));
}
self.forget(task);
if chain.is_empty() {
return Ok(());
}
let mut levels = Vec::with_capacity(chain.len());
for (init, pid) in chain.iter().copied().zip(nspid[1..].iter().copied()) {
let fresh = init == task && pid == 1;
if let Some(&highest) = self.highest.get(&init)
&& !fresh
&& pid <= highest
{
return Err(PidNamespaceRecordError::Wrapped {
namespace: init,
pid,
highest,
});
}
levels.push((init, pid));
}
for &(init, pid) in &levels {
self.highest.insert(init, pid);
self.tasks.insert((init, pid), task);
}
self.levels.insert(task, levels);
Ok(())
}
pub fn mark_untranslatable(&mut self, task: DetTid, reason: String) {
self.forget(task);
self.untranslatable.insert(task, reason);
}
pub fn untranslatable(&self, task: DetTid) -> Option<&str> {
self.untranslatable.get(&task).map(String::as_str)
}
pub fn resolve_for(&self, caller: DetTid, pid: i32) -> GuestPidAnswer {
if let Some(reason) = self.untranslatable(caller) {
return GuestPidAnswer::Untranslatable(reason.to_owned());
}
match self.resolve(self.namespace_of(caller), pid) {
Some(task) => GuestPidAnswer::Task {
task,
own_init_caught: None,
},
None => GuestPidAnswer::NoSuchPid,
}
}
pub fn localize_for(&self, caller: DetTid, task: DetTid) -> Result<Option<i32>, String> {
if let Some(reason) = self.untranslatable(caller) {
return Err(reason.to_owned());
}
if self.namespace_of(caller).is_some()
&& let Some(reason) = self.untranslatable(task)
{
return Err(reason.to_owned());
}
Ok(self.localize(self.namespace_of(caller), task))
}
pub fn forget(&mut self, task: DetTid) {
self.untranslatable.remove(&task);
if let Some(levels) = self.levels.remove(&task) {
for key in levels {
if self.tasks.get(&key) == Some(&task) {
self.tasks.remove(&key);
}
}
}
}
pub fn members(&self, init: DetPid) -> Vec<DetTid> {
self.levels
.iter()
.filter(|(_, levels)| levels.iter().any(|(level, _)| *level == init))
.map(|(task, _)| *task)
.collect()
}
pub fn resolve(&self, namespace: PidNamespace, pid: i32) -> Option<DetTid> {
match namespace {
None => Some(DetTid::from_raw(pid)),
Some(init) => self.tasks.get(&(init, pid)).copied(),
}
}
pub fn localize(&self, namespace: PidNamespace, task: DetTid) -> Option<i32> {
match namespace {
None => Some(task.as_raw()),
Some(init) => self
.levels
.get(&task)?
.iter()
.find(|(level, _)| *level == init)
.map(|(_, pid)| *pid),
}
}
}
pub fn read_nspid(pid: DetPid, tid: DetTid) -> Result<Vec<i32>, String> {
let path = format!("/proc/{}/task/{}/status", pid, tid);
let status = std::fs::read_to_string(&path).map_err(|e| format!("{path}: {e}"))?;
let line = status
.lines()
.find_map(|line| line.strip_prefix("NSpid:"))
.ok_or_else(|| format!("{path} has no NSpid line"))?;
line.split_whitespace()
.map(|field| {
field
.parse::<i32>()
.map_err(|e| format!("{path}: NSpid field {field:?}: {e}"))
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
fn t(n: i32) -> DetTid {
DetTid::from_raw(n)
}
fn family() -> PidNamespaces {
let mut ns = PidNamespaces::default();
ns.record(t(4), &[t(4)], &[4, 1]).unwrap();
ns.record(t(5), &[t(4)], &[5, 2]).unwrap();
ns.record(t(6), &[t(4), t(6)], &[6, 3, 1]).unwrap();
ns.record(t(7), &[t(4), t(6)], &[7, 4, 2]).unwrap();
ns
}
#[test]
fn a_nested_pid_resolves_to_its_own_namespaces_task() {
let ns = family();
assert_eq!(ns.resolve(Some(t(4)), 1), Some(t(4)));
assert_eq!(ns.resolve(Some(t(4)), 3), Some(t(6)));
assert_eq!(ns.resolve(Some(t(6)), 2), Some(t(7)));
assert_eq!(ns.resolve(Some(t(4)), 9), None);
assert_eq!(ns.resolve(Some(t(6)), 3), None);
assert_eq!(ns.resolve(None, 3), Some(t(3)));
}
#[test]
fn a_task_is_localized_only_where_it_is_visible() {
let ns = family();
assert_eq!(ns.localize(Some(t(4)), t(7)), Some(4));
assert_eq!(ns.localize(Some(t(6)), t(7)), Some(2));
assert_eq!(ns.localize(Some(t(6)), t(5)), None);
assert_eq!(ns.localize(Some(t(4)), t(3)), None);
assert_eq!(ns.localize(None, t(7)), Some(7));
assert_eq!(ns.namespace_of(t(7)), Some(t(6)));
assert_eq!(ns.namespace_of(t(3)), None);
assert_eq!(ns.chain_of(t(7)), vec![t(4), t(6)]);
assert_eq!(ns.members(t(4)), vec![t(4), t(5), t(6), t(7)]);
assert_eq!(ns.members(t(6)), vec![t(6), t(7)]);
}
#[test]
fn a_reaped_task_names_nothing() {
let mut ns = family();
ns.forget(t(5));
assert_eq!(ns.resolve(Some(t(4)), 2), None);
assert_eq!(ns.localize(Some(t(4)), t(5)), None);
}
#[test]
fn a_pid_at_or_below_the_namespaces_highest_is_a_wrap() {
let mut ns = family();
ns.forget(t(5));
assert_eq!(
ns.record(t(8), &[t(4)], &[8, 2]),
Err(PidNamespaceRecordError::Wrapped {
namespace: t(4),
pid: 2,
highest: 4
})
);
assert!(ns.record(t(8), &[t(4)], &[8, 5]).is_ok());
}
#[test]
fn an_nspid_that_does_not_fit_the_chain_is_refused() {
let mut ns = PidNamespaces::default();
assert!(matches!(
ns.record(t(4), &[t(4)], &[4]),
Err(PidNamespaceRecordError::Mismatch(_))
));
assert!(matches!(
ns.record(t(4), &[t(4)], &[5, 1]),
Err(PidNamespaceRecordError::Mismatch(_))
));
assert!(ns.record(t(3), &[], &[3]).is_ok());
}
}