use super::{
Capabilities, Error, KdamondCommand, ManagedHierarchy, QuotaGoalConfig, RawSnapshot, Result,
SchemeStats, retry_busy, with_rollback,
};
#[derive(Debug)]
pub struct ManagedKdamond<'a> {
pub(super) hierarchy: &'a mut ManagedHierarchy,
pub(super) index: usize,
}
impl ManagedKdamond<'_> {
#[must_use]
pub const fn index(&self) -> usize {
self.index
}
pub fn capabilities(&self, context_index: usize, scheme_index: usize) -> Result<Capabilities> {
self.hierarchy
.capabilities(self.index, context_index, scheme_index)
}
pub fn is_running(&self) -> Result<bool> {
self.hierarchy.is_running(self.index)
}
pub fn pause(&mut self) -> Result<()> {
self.pause_context(0)
}
pub fn resume(&mut self) -> Result<()> {
self.resume_context(0)
}
pub fn pause_context(&mut self, context_index: usize) -> Result<()> {
self.set_context_paused(context_index, true)
}
pub fn resume_context(&mut self, context_index: usize) -> Result<()> {
self.set_context_paused(context_index, false)
}
pub fn scheme_stats(
&mut self,
context_index: usize,
scheme_index: usize,
) -> Result<SchemeStats> {
self.runtime_batch(|batch| batch.scheme_stats(context_index, scheme_index))
}
pub fn cached_scheme_stats(
&self,
context_index: usize,
scheme_index: usize,
) -> Result<SchemeStats> {
self.hierarchy.verify_running(self.index)?;
let stats = self
.hierarchy
.scheme(self.index, context_index, scheme_index)?
.stats()?;
self.hierarchy.verify_running_identity(self.index)?;
Ok(stats)
}
pub fn tried_regions(
&mut self,
context_index: usize,
scheme_index: usize,
capacity_hint: usize,
) -> Result<RawSnapshot> {
self.runtime_batch(|batch| batch.tried_regions(context_index, scheme_index, capacity_hint))
}
pub fn cached_tried_regions(
&self,
context_index: usize,
scheme_index: usize,
capacity_hint: usize,
) -> Result<RawSnapshot> {
self.hierarchy.verify_running(self.index)?;
let snapshot = self
.hierarchy
.scheme(self.index, context_index, scheme_index)?
.tried_regions(capacity_hint)?;
self.hierarchy.verify_running_identity(self.index)?;
Ok(snapshot)
}
pub fn tried_bytes_units(&mut self, context_index: usize, scheme_index: usize) -> Result<u64> {
self.runtime_batch(|batch| batch.tried_bytes_units(context_index, scheme_index))
}
pub fn cached_tried_bytes_units(
&self,
context_index: usize,
scheme_index: usize,
) -> Result<u64> {
self.hierarchy.verify_running(self.index)?;
let units = self
.hierarchy
.scheme(self.index, context_index, scheme_index)?
.tried_bytes_units()?;
self.hierarchy.verify_running_identity(self.index)?;
Ok(units)
}
pub fn effective_quota_units(
&mut self,
context_index: usize,
scheme_index: usize,
) -> Result<u64> {
self.runtime_batch(|batch| batch.effective_quota_units(context_index, scheme_index))
}
pub fn cached_effective_quota_units(
&self,
context_index: usize,
scheme_index: usize,
) -> Result<u64> {
self.hierarchy.verify_running(self.index)?;
let units = self
.hierarchy
.scheme(self.index, context_index, scheme_index)?
.quotas()
.effective_size_units()?;
self.hierarchy.verify_running_identity(self.index)?;
Ok(units)
}
pub fn update_scheme_quota_goals(
&mut self,
context_index: usize,
scheme_index: usize,
goals: &[QuotaGoalConfig],
) -> Result<()> {
self.hierarchy
.update_scheme_quota_goals(self.index, context_index, scheme_index, goals)
}
pub fn runtime_batch<T>(
&mut self,
operation: impl FnOnce(&mut RuntimeBatch<'_>) -> Result<T>,
) -> Result<T> {
self.hierarchy.verify_running(self.index)?;
let result = {
let kdamond = self.hierarchy.kdamond(self.index);
let mut batch = RuntimeBatch {
hierarchy: self.hierarchy,
kdamond_index: self.index,
kdamond,
context_count: None,
cached_context: None,
};
operation(&mut batch)
};
self.hierarchy.verify_running_identity(self.index)?;
result
}
pub fn read_batch<T>(
&self,
operation: impl FnOnce(&mut RuntimeReadBatch<'_>) -> Result<T>,
) -> Result<T> {
self.hierarchy.verify_running(self.index)?;
let result = {
let kdamond = self.hierarchy.kdamond(self.index);
let mut batch = RuntimeReadBatch {
hierarchy: self.hierarchy,
kdamond_index: self.index,
kdamond,
context_count: None,
cached_context: None,
};
operation(&mut batch)
};
self.hierarchy.verify_running_identity(self.index)?;
result
}
#[allow(clippy::redundant_closure_for_method_calls)]
pub fn update_tuned_intervals(&mut self) -> Result<()> {
self.runtime_batch(|batch| batch.update_tuned_intervals())
}
#[allow(clippy::redundant_closure_for_method_calls)]
pub fn clear_tried_regions(&mut self) -> Result<()> {
self.runtime_batch(|batch| batch.clear_tried_regions())
}
fn set_context_paused(&mut self, context_index: usize, paused: bool) -> Result<()> {
self.hierarchy.verify_running(self.index)?;
let kdamond = self.hierarchy.kdamond(self.index);
let context_count = kdamond.context_count()?;
if context_index >= context_count {
return Err(Error::IndexOutOfBounds {
kind: "context",
index: context_index,
count: context_count,
});
}
let context = kdamond.context(context_index);
if !context.pause_control_available()? {
return Err(Error::UnsupportedFeature {
feature: "DAMON context pause",
});
}
let previous = context.is_paused()?;
if previous == paused {
self.hierarchy.verify_running_identity(self.index)?;
return Ok(());
}
let previous_fingerprint = self.hierarchy.staged.configuration.clone();
let pause_path = context.path().join("pause");
context.set_paused(paused)?;
let operation = (|| {
retry_busy(|| kdamond.command(&KdamondCommand::Commit))?;
self.hierarchy.verify_running_identity_only(self.index)?;
let observed = context.is_paused()?;
if observed != paused {
return Err(Error::ConfigurationMismatch {
path: format!("contexts/{context_index}/pause").into(),
expected: paused.to_string().into(),
observed: observed.to_string().into(),
});
}
let refreshed = self.hierarchy.staged.configuration.refreshed_paths_except(
std::slice::from_ref(&pause_path),
&self.hierarchy.staged.volatile_paths,
)?;
self.hierarchy.verify_running_identity_only(self.index)?;
self.hierarchy.staged.configuration = refreshed;
Ok(())
})();
if let Err(operation) = operation {
let rollback = (|| {
context.set_paused(previous)?;
retry_busy(|| kdamond.command(&KdamondCommand::Commit))?;
let restored = previous_fingerprint.refreshed_paths_except(
std::slice::from_ref(&pause_path),
&self.hierarchy.staged.volatile_paths,
)?;
self.hierarchy.verify_running_identity_only(self.index)?;
self.hierarchy.staged.configuration = restored;
Ok(())
})();
return Err(with_rollback(operation, rollback));
}
Ok(())
}
}
#[derive(Debug)]
pub struct HierarchyRuntimeBatch<'a> {
pub(super) hierarchy: &'a mut ManagedHierarchy,
}
impl HierarchyRuntimeBatch<'_> {
pub fn kdamond(&mut self, kdamond_index: usize) -> Result<RuntimeBatch<'_>> {
self.hierarchy.expected_running_pid(kdamond_index)?;
let kdamond = self.hierarchy.kdamond(kdamond_index);
Ok(RuntimeBatch {
hierarchy: self.hierarchy,
kdamond_index,
kdamond,
context_count: None,
cached_context: None,
})
}
}
#[derive(Debug)]
pub struct HierarchyReadBatch<'a> {
pub(super) hierarchy: &'a ManagedHierarchy,
}
impl HierarchyReadBatch<'_> {
pub fn kdamond(&mut self, kdamond_index: usize) -> Result<RuntimeReadBatch<'_>> {
self.hierarchy.expected_running_pid(kdamond_index)?;
let kdamond = self.hierarchy.kdamond(kdamond_index);
Ok(RuntimeReadBatch {
hierarchy: self.hierarchy,
kdamond_index,
kdamond,
context_count: None,
cached_context: None,
})
}
}
#[derive(Debug)]
pub struct RuntimeBatch<'a> {
pub(super) hierarchy: &'a mut ManagedHierarchy,
pub(super) kdamond_index: usize,
kdamond: crate::sysfs::Kdamond,
context_count: Option<usize>,
cached_context: Option<(usize, crate::sysfs::Context, usize)>,
}
impl RuntimeBatch<'_> {
#[must_use]
pub const fn kdamond_index(&self) -> usize {
self.kdamond_index
}
pub fn scheme_stats(
&mut self,
context_index: usize,
scheme_index: usize,
) -> Result<SchemeStats> {
let scheme = self.scheme(context_index, scheme_index)?;
self.issue_command(&KdamondCommand::UpdateSchemesStats)?;
let stats = scheme.stats()?;
self.verify_identity()?;
Ok(stats)
}
pub fn cached_scheme_stats(
&mut self,
context_index: usize,
scheme_index: usize,
) -> Result<SchemeStats> {
let stats = self.scheme(context_index, scheme_index)?.stats()?;
self.verify_identity()?;
Ok(stats)
}
pub fn tried_regions(
&mut self,
context_index: usize,
scheme_index: usize,
capacity_hint: usize,
) -> Result<RawSnapshot> {
let scheme = self.scheme(context_index, scheme_index)?;
self.issue_command(&KdamondCommand::UpdateSchemesTriedRegions)?;
let snapshot = scheme.tried_regions(capacity_hint)?;
self.verify_identity()?;
Ok(snapshot)
}
pub fn cached_tried_regions(
&mut self,
context_index: usize,
scheme_index: usize,
capacity_hint: usize,
) -> Result<RawSnapshot> {
let snapshot = self
.scheme(context_index, scheme_index)?
.tried_regions(capacity_hint)?;
self.verify_identity()?;
Ok(snapshot)
}
pub fn tried_bytes_units(&mut self, context_index: usize, scheme_index: usize) -> Result<u64> {
let scheme = self.scheme(context_index, scheme_index)?;
self.issue_command(&KdamondCommand::UpdateSchemesTriedBytes)?;
let units = scheme.tried_bytes_units()?;
self.verify_identity()?;
Ok(units)
}
pub fn cached_tried_bytes_units(
&mut self,
context_index: usize,
scheme_index: usize,
) -> Result<u64> {
let units = self
.scheme(context_index, scheme_index)?
.tried_bytes_units()?;
self.verify_identity()?;
Ok(units)
}
pub fn effective_quota_units(
&mut self,
context_index: usize,
scheme_index: usize,
) -> Result<u64> {
let scheme = self.scheme(context_index, scheme_index)?;
self.issue_command(&KdamondCommand::UpdateSchemesEffectiveQuotas)?;
let units = scheme.quotas().effective_size_units()?;
self.verify_identity()?;
Ok(units)
}
pub fn cached_effective_quota_units(
&mut self,
context_index: usize,
scheme_index: usize,
) -> Result<u64> {
let units = self
.scheme(context_index, scheme_index)?
.quotas()
.effective_size_units()?;
self.verify_identity()?;
Ok(units)
}
pub fn update_tuned_intervals(&mut self) -> Result<()> {
self.command(&KdamondCommand::UpdateTunedIntervals)
}
pub fn clear_tried_regions(&mut self) -> Result<()> {
self.command(&KdamondCommand::ClearSchemesTriedRegions)
}
fn scheme(
&mut self,
context_index: usize,
scheme_index: usize,
) -> Result<crate::sysfs::Scheme> {
cached_scheme(
&self.kdamond,
context_index,
scheme_index,
&mut self.context_count,
&mut self.cached_context,
)
}
fn command(&self, command: &KdamondCommand) -> Result<()> {
self.issue_command(command)?;
self.verify_identity()
}
fn issue_command(&self, command: &KdamondCommand) -> Result<()> {
self.verify_identity()?;
retry_busy(|| self.kdamond.command(command))
}
fn verify_identity(&self) -> Result<()> {
self.hierarchy
.verify_running_identity_with(self.kdamond_index, &self.kdamond)
}
}
#[derive(Debug)]
pub struct RuntimeReadBatch<'a> {
hierarchy: &'a ManagedHierarchy,
kdamond_index: usize,
kdamond: crate::sysfs::Kdamond,
context_count: Option<usize>,
cached_context: Option<(usize, crate::sysfs::Context, usize)>,
}
impl RuntimeReadBatch<'_> {
#[must_use]
pub const fn kdamond_index(&self) -> usize {
self.kdamond_index
}
pub fn scheme_stats(
&mut self,
context_index: usize,
scheme_index: usize,
) -> Result<SchemeStats> {
let stats = self.scheme(context_index, scheme_index)?.stats()?;
self.verify_identity()?;
Ok(stats)
}
pub fn tried_regions(
&mut self,
context_index: usize,
scheme_index: usize,
capacity_hint: usize,
) -> Result<RawSnapshot> {
let snapshot = self
.scheme(context_index, scheme_index)?
.tried_regions(capacity_hint)?;
self.verify_identity()?;
Ok(snapshot)
}
pub fn tried_bytes_units(&mut self, context_index: usize, scheme_index: usize) -> Result<u64> {
let units = self
.scheme(context_index, scheme_index)?
.tried_bytes_units()?;
self.verify_identity()?;
Ok(units)
}
pub fn effective_quota_units(
&mut self,
context_index: usize,
scheme_index: usize,
) -> Result<u64> {
let units = self
.scheme(context_index, scheme_index)?
.quotas()
.effective_size_units()?;
self.verify_identity()?;
Ok(units)
}
fn scheme(
&mut self,
context_index: usize,
scheme_index: usize,
) -> Result<crate::sysfs::Scheme> {
cached_scheme(
&self.kdamond,
context_index,
scheme_index,
&mut self.context_count,
&mut self.cached_context,
)
}
fn verify_identity(&self) -> Result<()> {
self.hierarchy
.verify_running_identity_with(self.kdamond_index, &self.kdamond)
}
}
fn cached_scheme(
kdamond: &crate::sysfs::Kdamond,
context_index: usize,
scheme_index: usize,
context_count: &mut Option<usize>,
cached_context: &mut Option<(usize, crate::sysfs::Context, usize)>,
) -> Result<crate::sysfs::Scheme> {
let count = if let Some(count) = *context_count {
count
} else {
let count = kdamond.context_count()?;
*context_count = Some(count);
count
};
if context_index >= count {
return Err(Error::IndexOutOfBounds {
kind: "context",
index: context_index,
count,
});
}
if let Some((cached_index, context, scheme_count)) = cached_context.as_ref() {
if *cached_index == context_index {
if scheme_index >= *scheme_count {
return Err(Error::IndexOutOfBounds {
kind: "scheme",
index: scheme_index,
count: *scheme_count,
});
}
return Ok(context.scheme(scheme_index));
}
}
let context = kdamond.context(context_index);
let scheme_count = context.scheme_count()?;
if scheme_index >= scheme_count {
return Err(Error::IndexOutOfBounds {
kind: "scheme",
index: scheme_index,
count: scheme_count,
});
}
let scheme = context.scheme(scheme_index);
*cached_context = Some((context_index, context, scheme_count));
Ok(scheme)
}