use std::{
collections::{BTreeSet, HashMap},
env, io,
ops::Range,
os::fd::{AsFd, BorrowedFd, OwnedFd},
time::Duration,
};
use rustix::{
io::{Errno, fcntl_dupfd_cloexec},
pipe::{PipeFlags, pipe_with},
};
use crate::{
Error, Passed, Restored, Result, Save,
layout::{self, Entry, Layout},
memfd,
notifier::{MAX_FDS, Notifier},
queue::{self, Queue},
restored::Slot,
};
#[derive(Debug)]
pub struct Store {
notifier: Notifier,
key: String,
max: usize,
reserve: Option<Reserve>,
}
impl Store {
pub fn from_env(key: &str, passed: &Passed) -> Result<Self> {
let notifier = Notifier::from_env()?.ok_or(Error::NoManager)?;
let max = fd_store_max().ok_or(Error::NoStore)?;
let store = Self::with_notifier(notifier, key, max)?;
if !passed.had_other_than(&format!("{key}/")) {
return Err(Error::NoSocket);
}
Ok(store)
}
pub fn take_over(&mut self, passed: &mut Passed) -> Result<Option<Restored>> {
let restored = self.take_handover(passed);
if let Err(e) = self.notifier.notify("READY=1") {
warn!("Failed to tell systemd that the service has started: {e}");
}
restored
}
pub fn hand_over<S, I, T>(self, state: S, items: I) -> Result<Stored>
where
S: Save,
I: IntoIterator<Item = (u64, T)>,
T: Save,
{
let items: Vec<_> = items.into_iter().collect();
let items: Vec<_> = items
.iter()
.map(|(id, item)| (*id, item as &dyn Save))
.collect();
self.store_all(&state, &items)
}
pub(crate) fn with_notifier(notifier: Notifier, key: &str, max: usize) -> Result<Self> {
check_key(key)?;
if max < MIN_STORE {
return Err(Error::StoreTooSmall { max });
}
let reserve = Reserve::new()
.inspect_err(|e| warn!("Failed to keep file descriptors to hand over with: {e}"))
.ok();
Ok(Self {
notifier,
key: key.to_owned(),
max,
reserve,
})
}
fn take_handover(&self, passed: &mut Passed) -> Result<Option<Restored>> {
let prefix = format!("{}/", self.key);
let stored = passed.take_prefixed(&prefix);
let names: BTreeSet<_> = stored.iter().map(|(name, _)| name.as_str()).collect();
for name in names {
if let Err(e) = self.notifier.remove(name) {
warn!("Failed to remove `{name}` from the file descriptor store: {e}");
}
}
let mut state = None;
let mut queues = Vec::new();
for (name, fd) in stored {
match &name[prefix.len()..] {
STATE if state.is_none() => state = Some(fd),
FDS => queues.push(fd),
_ => {
warn!("Closing `{name}` of the file descriptor store, which zoter doesn't know")
}
}
}
let Some(state) = state else {
if !queues.is_empty() {
warn!("Closing the file descriptors that were stored without their hand-over");
}
return Ok(None);
};
let view = memfd::view(state.as_fd())?;
let contents = layout::read(&view)?;
let mut fds = take_queued(queues)?;
let state_fds = take_fds(&mut fds, 0..contents.state_fds).ok_or_else(|| {
Error::InvalidHandover(
"file descriptors of the state of the hand-over are missing".to_owned(),
)
})?;
let mut items = Vec::with_capacity(contents.entries.len());
for Entry {
id,
record,
fds: indexes,
} in contents.entries
{
let Some(fds) = take_fds(&mut fds, indexes) else {
return Err(Error::InvalidHandover(format!(
"file descriptors of item {id} of the hand-over are missing"
)));
};
items.push(Slot { id, record, fds });
}
if !fds.is_empty() {
warn!(
"Closing {} file descriptors of the store that no item of the hand-over has",
fds.len()
);
}
Ok(Some(Restored {
view,
state: contents.state,
state_fds,
items,
}))
}
fn store_all(mut self, state: &dyn Save, items: &[(u64, &dyn Save)]) -> Result<Stored> {
let room = self.max - 1;
self.reserve = None;
let state_len = state.saved_len().ok_or(Error::Unsaved {
item: None,
source: None,
})?;
let lens = items
.iter()
.map(|(id, item)| {
item.saved_len().ok_or(Error::Unsaved {
item: Some(*id),
source: None,
})
})
.collect::<Result<Vec<_>>>()?;
let state_fds = state.fds();
let item_fds: Vec<_> = items.iter().map(|(_, item)| item.fds()).collect();
let layout = Layout::new(state_len, lens.into_iter())?;
{
let name = self.name(STATE);
let memfd = memfd::filled(&name, layout.len(), |memfd| -> Result<()> {
state
.save(&mut memfd[layout.state()])
.map_err(|e| Error::Unsaved {
item: None,
source: Some(Box::new(e)),
})?;
let mut entries = Vec::with_capacity(items.len());
let mut next = state_fds.len() as u64;
for (place, ((id, item), fds)) in items.iter().zip(&item_fds).enumerate() {
item.save(&mut memfd[layout.item(place)])
.map_err(|e| Error::Unsaved {
item: Some(*id),
source: Some(Box::new(e)),
})?;
let first = next;
next += fds.len() as u64;
entries.push(Entry {
id: *id,
record: layout.item(place),
fds: first..next,
});
}
layout.write(memfd, state_fds.len(), &entries);
Ok(())
})?;
self.notifier.store(&name, &[memfd.as_fd()])?;
}
let fds: Vec<_> = state_fds
.iter()
.chain(item_fds.iter().flatten())
.copied()
.collect();
let name = self.name(FDS);
queue_fds(fds.chunks(MAX_FDS), room, |socket| {
self.notifier.store(&name, &[socket.as_fd()])
})?;
self.notifier.barrier(BARRIER_TIMEOUT)?;
debug!(
"Stored {} items and {} file descriptors under `{}` for the next instance",
items.len(),
fds.len(),
self.key
);
Ok(Stored {
items: items.len(),
fds: fds.len(),
})
}
fn name(&self, kind: &str) -> String {
format!("{}/{kind}", self.key)
}
}
#[derive(Debug)]
pub struct Stored {
items: usize,
fds: usize,
}
impl Stored {
pub fn items(&self) -> usize {
self.items
}
pub fn fds(&self) -> usize {
self.fds
}
}
#[derive(Debug)]
struct Reserve {
_storing: [OwnedFd; 3],
}
impl Reserve {
fn new() -> io::Result<Self> {
let (read, write) = pipe_with(PipeFlags::CLOEXEC)?;
let duplicate = fcntl_dupfd_cloexec(&read, 0)?;
Ok(Self {
_storing: [read, write, duplicate],
})
}
}
fn queue_fds<'c, 'f, C, S>(chunks: C, room: usize, mut store: S) -> Result<()>
where
'f: 'c,
C: IntoIterator<Item = &'c [BorrowedFd<'f>]>,
S: FnMut(OwnedFd) -> Result<()>,
{
let mut chunks = chunks.into_iter().peekable();
let mut index = 0;
for _ in 0..room {
if chunks.peek().is_none() {
return Ok(());
}
let queue = Queue::new()?;
let mut took = false;
while let Some(chunk) = chunks.peek() {
let pushed = queue.push(index, chunk).map_err(|e| {
io::Error::new(
e.kind(),
format!("the file descriptors of the hand-over failed to be queued: {e}"),
)
})?;
if !pushed {
break;
}
index += chunk.len() as u64;
took = true;
chunks.next();
}
if !took {
return Err(io::Error::other(
"a queue socket took none of the file descriptors of the hand-over",
)
.into());
}
store(queue.into_socket())?;
}
if chunks.peek().is_none() {
return Ok(());
}
Err(Error::StoreFull)
}
fn take_queued(queues: Vec<OwnedFd>) -> Result<HashMap<u64, OwnedFd>> {
let mut fds = HashMap::new();
let mut complete = true;
for queue in queues {
let taken = queue::take(queue.as_fd(), |index, taken, all| {
for (n, fd) in (0..).zip(taken) {
fds.insert(index.wrapping_add(n), fd);
}
complete &= all;
});
if let Err(e) = taken {
warn!("Failed to take file descriptors of the hand-over out of the store: {e}");
}
}
if !complete {
warn!(
"Failed to take file descriptors of the hand-over out of the store, as the process has \
too many open: raise the hard limit of `LimitNOFILE=` of the service."
);
return Err(Error::os(Errno::MFILE));
}
Ok(fds)
}
fn take_fds(fds: &mut HashMap<u64, OwnedFd>, indexes: Range<u64>) -> Option<Vec<OwnedFd>> {
if indexes.end.saturating_sub(indexes.start) > fds.len() as u64 {
fds.retain(|index, _| !indexes.contains(index));
return None;
}
let taken: Vec<_> = indexes.map(|index| fds.remove(&index)).collect();
taken.into_iter().collect()
}
fn fd_store_max() -> Option<usize> {
env::var("FDSTORE").ok()?.parse().ok()
}
fn check_key(key: &str) -> Result<()> {
let valid = |b: u8| (b' '..=b'~').contains(&b) && b != b':' && b != b'/';
if key.is_empty() || key.len() > MAX_KEY_LEN || !key.bytes().all(valid) {
return Err(Error::InvalidName(format!(
"a key is 1 to {MAX_KEY_LEN} printable ASCII characters, other than `:` and `/`"
)));
}
Ok(())
}
pub(crate) const MIN_STORE: usize = 2;
const BARRIER_TIMEOUT: Duration = Duration::from_secs(5);
const MAX_KEY_LEN: usize = 200;
const STATE: &str = "state";
const FDS: &str = "fds";
#[cfg(test)]
mod tests;