use std::collections::{BTreeMap, BTreeSet};
use std::fmt;
use crate::config::{AbsPath, MountAttrs};
use crate::identity::{DevIno, MountIdentity};
use crate::name::GroupId;
use crate::state::{MountRecord, RecordKey, State};
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Location {
pub root: AbsPath,
pub path: String,
}
impl fmt::Display for Location {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if self.root.as_path() == std::path::Path::new("/") {
write!(f, "/{}", self.path)
} else {
write!(f, "{}/{}", self.root, self.path)
}
}
}
impl MountRecord {
#[must_use]
pub fn source_location(&self) -> Location {
Location {
root: self.source_root.clone(),
path: self.source.clone(),
}
}
#[must_use]
pub fn target_location(&self) -> Location {
Location {
root: self.target_root.clone(),
path: self.target.clone(),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DesiredMount {
pub key: RecordKey,
pub source: Location,
pub target: Location,
pub attrs: MountAttrs,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[allow(clippy::struct_excessive_bools)]
pub struct ObservedAttrs {
pub read_only: bool,
pub nosuid: bool,
pub nodev: bool,
pub noexec: bool,
pub nosymfollow: bool,
}
impl ObservedAttrs {
#[must_use]
pub fn enforce(&self, attrs: &MountAttrs) -> bool {
self.nosuid
&& self.nodev
&& (self.read_only || !attrs.read_only)
&& (self.noexec || !attrs.noexec)
&& (self.nosymfollow || !attrs.nosymfollow)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SourceState {
Resolved(DevIno),
Unavailable(String),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TargetState {
NotMounted,
Mounted {
identity: MountIdentity,
attrs: Option<ObservedAttrs>,
},
Unavailable(String),
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct Observations {
pub sources: BTreeMap<RecordKey, SourceState>,
pub targets: BTreeMap<Location, TargetState>,
}
#[derive(Debug, Clone, Copy)]
pub struct PlanInput<'a> {
pub desired: &'a [DesiredMount],
pub state: &'a State,
pub frozen_groups: &'a BTreeSet<GroupId>,
pub observations: &'a Observations,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum UnmountReason {
NotMember,
Relocated,
SourceGone(String),
SourceChanged,
TargetCollision,
AttributesChanged,
AttributesDrifted,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DropReason {
MountGone,
ForeignMountAtTarget,
SourceUnavailable(String),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Action {
Unmount {
record: MountRecord,
reason: UnmountReason,
},
DropRecord {
record: MountRecord,
reason: DropReason,
},
Mount {
desired: DesiredMount,
},
}
impl Action {
const fn phase(&self) -> u8 {
match self {
Self::Unmount { .. } | Self::DropRecord { .. } => 0,
Self::Mount { .. } => 1,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Step {
pub action: Action,
pub depends_on: Vec<usize>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ConflictKind {
ForeignMount,
TargetReplaced,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Finding {
Conflict {
key: RecordKey,
target: Location,
kind: ConflictKind,
},
SourceUnavailable {
key: RecordKey,
source: Location,
reason: String,
},
TargetUnavailable {
key: RecordKey,
target: Location,
reason: String,
},
TargetCollision {
target: Location,
members: Vec<RecordKey>,
kept: Option<RecordKey>,
},
RelocationBlocked {
key: RecordKey,
old_target: Location,
},
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct Plan {
pub steps: Vec<Step>,
pub findings: Vec<Finding>,
}
impl Plan {
#[must_use]
pub fn is_noop(&self) -> bool {
self.steps.is_empty()
}
}
fn record_matches_desired(record: &MountRecord, desired: &DesiredMount) -> bool {
record.source_location() == desired.source && record.target_location() == desired.target
}
struct Builder<'a> {
input: PlanInput<'a>,
steps: Vec<(Action, Vec<usize>)>,
findings: Vec<Finding>,
}
impl<'a> Builder<'a> {
fn push(&mut self, action: Action, depends_on: Vec<usize>) -> usize {
self.steps.push((action, depends_on));
self.steps.len() - 1
}
fn target(&self, location: &Location) -> TargetState {
self.input
.observations
.targets
.get(location)
.cloned()
.unwrap_or_else(|| TargetState::Unavailable("target was not observed".into()))
}
fn source(&self, key: &RecordKey) -> SourceState {
self.input
.observations
.sources
.get(key)
.cloned()
.unwrap_or_else(|| SourceState::Unavailable("source was not observed".into()))
}
fn resolve_collisions(&mut self) -> BTreeMap<RecordKey, &'a DesiredMount> {
let frozen = self.input.frozen_groups;
let mut by_target: BTreeMap<&Location, Vec<&'a DesiredMount>> = BTreeMap::new();
for d in self.input.desired {
if !frozen.contains(&d.key.group) {
by_target.entry(&d.target).or_default().push(d);
}
}
let mut accepted = BTreeMap::new();
for (target, mut members) in by_target {
if members.len() == 1 {
let d = members.remove(0);
accepted.insert(d.key.clone(), d);
continue;
}
members.sort_by(|a, b| a.key.cmp(&b.key));
let observed = self.target(target);
let kept = members.iter().copied().find(|d| {
let Some(record) = self.input.state.get(&d.key) else {
return false;
};
record_matches_desired(record, d)
&& matches!(&observed, TargetState::Mounted { identity, .. }
if identity.matches(&record.identity()))
});
if let Some(d) = kept {
accepted.insert(d.key.clone(), d);
}
self.findings.push(Finding::TargetCollision {
target: target.clone(),
members: members.iter().map(|d| d.key.clone()).collect(),
kept: kept.map(|d| d.key.clone()),
});
}
accepted
}
fn finish(self) -> Plan {
let mut order: Vec<usize> = (0..self.steps.len()).collect();
order.sort_by_key(|&id| self.steps[id].0.phase());
let mut index_of = vec![0; self.steps.len()];
for (index, &id) in order.iter().enumerate() {
index_of[id] = index;
}
let mut slots: Vec<Option<(Action, Vec<usize>)>> =
self.steps.into_iter().map(Some).collect();
let steps = order
.iter()
.map(|&id| {
let (action, deps) = slots[id]
.take()
.unwrap_or_else(|| unreachable!("step taken twice"));
let mut depends_on: Vec<usize> = deps.into_iter().map(|d| index_of[d]).collect();
depends_on.sort_unstable();
depends_on.dedup();
Step { action, depends_on }
})
.collect();
Plan {
steps,
findings: self.findings,
}
}
}
#[derive(Default)]
struct Departures {
old_record_removal: BTreeMap<RecordKey, Option<usize>>,
freed_targets: BTreeMap<Location, (usize, MountIdentity)>,
}
#[must_use]
pub fn plan(input: PlanInput<'_>) -> Plan {
let mut b = Builder {
input,
steps: Vec::new(),
findings: Vec::new(),
};
let desired = b.resolve_collisions();
let departures = plan_departing_records(&mut b, &desired);
for (key, d) in &desired {
let target = b.target(&d.target);
let source = b.source(key);
match input
.state
.get(key)
.filter(|r| record_matches_desired(r, d))
{
Some(record) => plan_recorded_member(&mut b, d, record, target, source),
None => plan_unrecorded_member(&mut b, d, &departures, target, source),
}
}
b.finish()
}
fn plan_departing_records(
b: &mut Builder<'_>,
desired: &BTreeMap<RecordKey, &DesiredMount>,
) -> Departures {
let input = b.input;
let mut departures = Departures::default();
for record in input.state.records() {
if input.frozen_groups.contains(&record.group) {
continue;
}
let key = record.key();
let desired_here = desired.get(&key).copied();
if desired_here.is_some_and(|d| record_matches_desired(record, d)) {
continue; }
let collided = desired_here.is_none()
&& input
.desired
.iter()
.any(|d| d.key == key && !input.frozen_groups.contains(&d.key.group));
let unmount_reason = if collided {
UnmountReason::TargetCollision
} else if desired_here.is_some() {
UnmountReason::Relocated
} else {
UnmountReason::NotMember
};
let location = record.target_location();
let drop_record = |b: &mut Builder<'_>, reason| {
b.push(
Action::DropRecord {
record: record.clone(),
reason,
},
vec![],
)
};
let removal = match b.target(&location) {
TargetState::NotMounted => Some(drop_record(b, DropReason::MountGone)),
TargetState::Mounted { identity, .. } if identity.matches(&record.identity()) => {
let id = b.push(
Action::Unmount {
record: record.clone(),
reason: unmount_reason,
},
vec![],
);
departures.freed_targets.insert(location, (id, identity));
Some(id)
}
TargetState::Mounted { .. } => Some(drop_record(b, DropReason::ForeignMountAtTarget)),
TargetState::Unavailable(reason) => {
b.findings.push(Finding::TargetUnavailable {
key: key.clone(),
target: location,
reason,
});
None
}
};
departures.old_record_removal.insert(key, removal);
}
departures
}
fn plan_unrecorded_member(
b: &mut Builder<'_>,
d: &DesiredMount,
departures: &Departures,
target: TargetState,
source: SourceState,
) {
let mut deps = Vec::new();
match departures.old_record_removal.get(&d.key) {
None => {}
Some(Some(id)) => deps.push(*id),
Some(None) => {
let old_target = b
.input
.state
.get(&d.key)
.map_or_else(|| d.target.clone(), MountRecord::target_location);
b.findings.push(Finding::RelocationBlocked {
key: d.key.clone(),
old_target,
});
return;
}
}
match target {
TargetState::NotMounted => {}
TargetState::Mounted { identity, .. } => {
let freed_by = departures
.freed_targets
.get(&d.target)
.filter(|(_, freed)| *freed == identity)
.map(|(id, _)| *id);
let Some(id) = freed_by else {
b.findings.push(Finding::Conflict {
key: d.key.clone(),
target: d.target.clone(),
kind: ConflictKind::ForeignMount,
});
return;
};
deps.push(id);
}
TargetState::Unavailable(reason) => {
b.findings.push(Finding::TargetUnavailable {
key: d.key.clone(),
target: d.target.clone(),
reason,
});
return;
}
}
match source {
SourceState::Resolved(_) => {
b.push(Action::Mount { desired: d.clone() }, deps);
}
SourceState::Unavailable(reason) => b.findings.push(Finding::SourceUnavailable {
key: d.key.clone(),
source: d.source.clone(),
reason,
}),
}
}
fn plan_recorded_member(
b: &mut Builder<'_>,
d: &DesiredMount,
record: &MountRecord,
target: TargetState,
source: SourceState,
) {
match target {
TargetState::Mounted { identity, attrs } if identity.matches(&record.identity()) => {
match source {
SourceState::Resolved(root) if root == record.identity().root => {
let reason = if record.attrs() != d.attrs {
Some(UnmountReason::AttributesChanged)
} else if attrs.is_some_and(|a| !a.enforce(&d.attrs)) {
Some(UnmountReason::AttributesDrifted)
} else {
None
};
if let Some(reason) = reason {
let id = b.push(
Action::Unmount {
record: record.clone(),
reason,
},
vec![],
);
b.push(Action::Mount { desired: d.clone() }, vec![id]);
}
}
SourceState::Resolved(_) => {
let id = b.push(
Action::Unmount {
record: record.clone(),
reason: UnmountReason::SourceChanged,
},
vec![],
);
b.push(Action::Mount { desired: d.clone() }, vec![id]);
}
SourceState::Unavailable(reason) => {
b.push(
Action::Unmount {
record: record.clone(),
reason: UnmountReason::SourceGone(reason),
},
vec![],
);
}
}
}
TargetState::Mounted { .. } => b.findings.push(Finding::Conflict {
key: d.key.clone(),
target: d.target.clone(),
kind: ConflictKind::TargetReplaced,
}),
TargetState::NotMounted => match source {
SourceState::Resolved(_) => {
b.push(Action::Mount { desired: d.clone() }, vec![]);
}
SourceState::Unavailable(reason) => {
b.push(
Action::DropRecord {
record: record.clone(),
reason: DropReason::SourceUnavailable(reason.clone()),
},
vec![],
);
b.findings.push(Finding::SourceUnavailable {
key: d.key.clone(),
source: d.source.clone(),
reason,
});
}
},
TargetState::Unavailable(reason) => b.findings.push(Finding::TargetUnavailable {
key: d.key.clone(),
target: d.target.clone(),
reason,
}),
}
}
#[cfg(test)]
mod tests;