Files
bootvine/src/systemd_link/boot_feed.rs
T
Willem Vanhulle 092ed41ffb perf: await systemd replies instead of blocking the screen
Calls send their message and await the reply on the registered socket while
the other streams keep drawing; signals that arrive meanwhile are queued for
the next receive. Restoring systemd's status output moves to a guard that
reconnects on exit, so it no longer depends on where the feed was suspended.
Status modes are an enum instead of raw strings.
2026-10-21 13:24:34 +02:00

397 lines
12 KiB
Rust

use std::{
collections::HashMap,
iter::once,
mem, process,
time::{Duration, Instant},
};
use dbus::Path;
use futures::{Stream, StreamExt, stream};
use tokio::time::sleep;
use crate::{
boot_model::{BootChange, BootState, HANDOFF_UNIT, JobKind, Phase},
console_session::{
stream_sources::{CarriedItem, FRAME_INTERVAL, unfold_carrying},
watch_screen::ScreenInput,
},
systemd_link::{
link_error::Error,
monotonic_clock::monotonic_now,
switch_root::Sysroot,
systemd_bus::{
BusConnection, FetchedUnit, JobListing, Scope, Session, Signal, StatusOutput,
},
},
};
const RECONNECT_PATIENCE: Duration = Duration::from_secs(60);
const SWITCH_ROOT_UNIT: &str = "initrd-switch-root.service";
const SHUTDOWN_ROOTS: [&str; 5] = [
"poweroff.target",
"reboot.target",
"halt.target",
"kexec.target",
"soft-reboot.target",
];
const SHUTDOWN_FALLBACK_ROOT: &str = "shutdown.target";
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum RootRequest {
Named(String),
ManagerDefault,
}
enum Link {
Connected(BusConnection),
Connecting { deadline: Instant },
Finished,
}
impl Link {
fn connecting() -> Self {
Self::Connecting {
deadline: Instant::now() + RECONNECT_PATIENCE,
}
}
}
enum RootFs {
Initrd,
SwitchingTo(Sysroot),
Host,
}
struct TrackedUnit {
name: String,
change: Option<BootChange>,
}
struct BusFeed {
scope: Scope,
target: RootRequest,
phase: Phase,
link: Link,
unit_paths: HashMap<Path<'static>, String>,
root_fs: RootFs,
gave_origin: bool,
}
struct FeedProgress<'feed> {
feed: &'feed mut BusFeed,
connection: &'feed mut BusConnection,
changes: Vec<BootChange>,
}
struct WatchedConnection {
connection: BusConnection,
changes: Vec<BootChange>,
}
fn boot_inputs(changes: Vec<BootChange>) -> Vec<ScreenInput> {
if changes.is_empty() {
return Vec::new();
}
vec![ScreenInput::Boot(changes)]
}
impl BusFeed {
fn new(phase: Phase, scope: Scope, target: RootRequest) -> Self {
Self {
scope,
target,
root_fs: if phase == Phase::Initrd {
RootFs::Initrd
} else {
RootFs::Host
},
phase,
link: Link::connecting(),
unit_paths: HashMap::new(),
gave_origin: false,
}
}
async fn next_inputs(&mut self) -> Option<Vec<ScreenInput>> {
match mem::replace(&mut self.link, Link::Finished) {
Link::Finished => None,
Link::Connecting { deadline } => Some(self.connect(deadline).await),
Link::Connected(connection) => Some(self.receive(connection).await),
}
}
async fn open_watched(&mut self) -> Result<WatchedConnection, Error> {
let mut connection = BusConnection::register(Session::open(self.scope)?)?;
let changes = self.start_watching(&mut connection).await?;
Ok(WatchedConnection {
connection,
changes,
})
}
async fn connect(&mut self, deadline: Instant) -> Vec<ScreenInput> {
match self.open_watched().await {
Ok(watched) => {
self.link = Link::Connected(watched.connection);
vec![ScreenInput::Boot(watched.changes), ScreenInput::Reconnected]
}
Err(_) if Instant::now() < deadline => {
sleep(FRAME_INTERVAL).await;
self.link = Link::Connecting { deadline };
Vec::new()
}
Err(_) => vec![ScreenInput::Failed(Error::ManagerUnreachable)],
}
}
async fn receive(&mut self, mut connection: BusConnection) -> Vec<ScreenInput> {
let Ok(signals) = connection.receive_signals(FRAME_INTERVAL).await else {
return self.lose_connection();
};
let progress = stream::iter(signals)
.fold(
FeedProgress {
feed: &mut *self,
connection: &mut connection,
changes: Vec::new(),
},
|mut progress, signal| async move {
let changes = progress.feed.changes_for(progress.connection, signal).await;
progress.changes.extend(changes);
progress
},
)
.await;
let changes = progress.changes;
self.link = Link::Connected(connection);
boot_inputs(changes)
}
fn lose_connection(&mut self) -> Vec<ScreenInput> {
let at = monotonic_now();
let RootFs::SwitchingTo(sysroot) = mem::replace(&mut self.root_fs, RootFs::Host) else {
if self.phase == Phase::Shutdown {
return boot_inputs(vec![BootChange::ManagerExited { at }]);
}
self.link = Link::connecting();
return boot_inputs(vec![BootChange::ForgetJobs]);
};
if let Err(error) = sysroot.enter() {
return vec![ScreenInput::Failed(error.into())];
}
self.unit_paths.clear();
self.phase = Phase::Host;
self.link = Link::connecting();
boot_inputs(vec![BootChange::SwitchRoot { at }])
}
async fn requested_root(
&self,
connection: &mut BusConnection,
jobs: &[JobListing],
) -> Result<String, Error> {
let RootRequest::Named(target) = &self.target else {
if self.phase != Phase::Shutdown {
return connection.default_target().await;
}
return Ok(SHUTDOWN_ROOTS
.into_iter()
.find(|root| {
jobs.iter()
.any(|job| job.unit == *root && job.kind == JobKind::BringsUp)
})
.unwrap_or(SHUTDOWN_FALLBACK_ROOT)
.to_owned());
};
Ok(target.clone())
}
async fn origin_change(
&mut self,
connection: &mut BusConnection,
) -> Result<Option<BootChange>, Error> {
if self.gave_origin {
return Ok(None);
}
self.gave_origin = true;
let origin = if connection.boot_in_progress().await? {
Duration::ZERO
} else {
monotonic_now()
};
Ok(Some(BootChange::SetOrigin(origin)))
}
async fn track_all(
&mut self,
connection: &mut BusConnection,
units: Vec<String>,
) -> Vec<BootChange> {
stream::iter(units)
.fold(
FeedProgress {
feed: &mut *self,
connection: &mut *connection,
changes: Vec::new(),
},
|mut progress, unit| async move {
let tracked = progress.feed.track(progress.connection, &unit).await;
progress
.changes
.extend(tracked.and_then(|tracked| tracked.change));
progress
},
)
.await
.changes
}
async fn start_watching(
&mut self,
connection: &mut BusConnection,
) -> Result<Vec<BootChange>, Error> {
connection.subscribe().await?;
if self.scope == Scope::System {
connection.set_show_status(StatusOutput::Silent).await.ok();
}
let shutting_down = self.phase == Phase::Shutdown;
let jobs: Vec<JobListing> = connection
.list_jobs()
.await?
.into_iter()
.filter(|job| shutting_down || job.kind == JobKind::BringsUp)
.collect();
let requested_root = self.requested_root(connection, &jobs).await?;
let origin_change = self.origin_change(connection).await?;
let tracked_root = self.track(connection, &requested_root).await;
let root = tracked_root
.as_ref()
.map_or(requested_root, |tracked| tracked.name.clone());
let tracked_handoff = self.track(connection, HANDOFF_UNIT).await;
let handoff = tracked_handoff
.as_ref()
.map(|tracked| BootChange::SetHandoff(tracked.name.clone()));
let watched_units = jobs
.iter()
.map(|job| job.unit.clone())
.chain(BootState::new(self.phase).milestone_targets)
.collect();
let tracked_changes = self.track_all(connection, watched_units).await;
eprintln!(
"bootvine: watching {root} in {} as pid {} over {}",
self.phase.label(),
process::id(),
if connection.peer_to_peer() {
"the private socket"
} else {
"the bus"
},
);
let queued_at = monotonic_now();
Ok(origin_change
.into_iter()
.chain(tracked_root.and_then(|tracked| tracked.change))
.chain(tracked_handoff.and_then(|tracked| tracked.change))
.chain(handoff)
.chain(tracked_changes)
.chain(once(BootChange::SetRoot(root)))
.chain(jobs.into_iter().map(|job| BootChange::QueueJob {
id: job.id,
unit: job.unit,
kind: job.kind,
at: queued_at,
}))
.collect())
}
async fn track(&mut self, connection: &mut BusConnection, unit: &str) -> Option<TrackedUnit> {
if let Some(known) = self.unit_paths.values().find(|known| *known == unit) {
return Some(TrackedUnit {
name: known.clone(),
change: None,
});
}
let FetchedUnit {
path,
facts,
activity,
} = connection.fetch_unit(unit).await.ok()?;
let name = facts.name.clone();
if self.unit_paths.values().any(|known| *known == name) {
return Some(TrackedUnit { name, change: None });
}
self.unit_paths.insert(path, name.clone());
Some(TrackedUnit {
name,
change: Some(BootChange::TrackUnit { facts, activity }),
})
}
async fn changes_for(
&mut self,
connection: &mut BusConnection,
signal: Signal,
) -> Vec<BootChange> {
let at = monotonic_now();
match signal {
Signal::JobNew { id, job, unit } => {
self.queue_new_job(connection, id, &job, unit, at).await
}
Signal::JobRemoved { id, result } => vec![BootChange::FinishJob { id, result, at }],
Signal::UnitChanged { path, activity } => self
.unit_paths
.get(&path)
.map(|unit| BootChange::UpdateActivity {
unit: unit.clone(),
activity,
})
.into_iter()
.collect(),
}
}
async fn queue_new_job(
&mut self,
connection: &mut BusConnection,
id: u32,
job: &Path<'static>,
unit: String,
at: Duration,
) -> Vec<BootChange> {
let kind = connection.job_kind(job).await.unwrap_or(JobKind::Unknown);
if kind == JobKind::TakesDown && self.phase != Phase::Shutdown {
return Vec::new();
}
let tracked = self.track(connection, &unit).await;
let unit = tracked
.as_ref()
.map_or(unit, |tracked| tracked.name.clone());
if matches!(self.root_fs, RootFs::Initrd)
&& unit == SWITCH_ROOT_UNIT
&& let Ok(sysroot) = Sysroot::hold()
{
self.root_fs = RootFs::SwitchingTo(sysroot);
}
tracked
.and_then(|tracked| tracked.change)
.into_iter()
.chain(once(BootChange::QueueJob { id, unit, kind, at }))
.collect()
}
}
pub fn bus_inputs(
phase: Phase,
scope: Scope,
target: RootRequest,
) -> impl Stream<Item = ScreenInput> {
unfold_carrying(BusFeed::new(phase, scope, target), |mut feed| async move {
let inputs = feed.next_inputs().await?;
Some(CarriedItem {
item: inputs,
state: feed,
})
})
.flat_map(stream::iter)
}