Qyriad/dynix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

remove the persistent buffer until a refactor makes it per-connection

Browse source
This commit is contained in:
Qyriad 2026-03-22 15:57:38 +01:00
parent bd3ec3a904
commit 88be53cd2f
1 changed files with 14 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

47
src/daemon.rs
View file

@ -1,5 +1,5 @@
use std::{
env, io, mem,
env, io,
ops::Deref,
os::fd::{AsFd, BorrowedFd, IntoRawFd, OwnedFd, RawFd},
sync::{
@ -135,9 +135,6 @@ pub struct Daemon {
// Bijective mapping of [`mio::Token`]s to [`RawFd`]s.
tokfd: BiHashMap<TokenFd>,
cmd_buffer: Vec<u8>,
next_timeout: Option<Duration>,
}
/// `tokfd` handling.
@ -222,6 +219,8 @@ impl Daemon {
.copied()
}
/// Not currently used, but here for completeness.
#[expect(dead_code)]
fn token_for_fd(&self, fd: RawFd) -> Option<Token> {
self.tokfd
.get2(&fd)
@ -267,8 +266,6 @@ impl Daemon {
poller,
fd_info,
tokfd: Default::default(),
cmd_buffer: Vec::with_capacity(1024),
next_timeout: TIMEOUT_NEVER,
}
}
@ -345,16 +342,12 @@ impl Daemon {
/// Private helpers.
impl Daemon {
fn read_cmd(&mut self, fd: &BorrowedFd) -> Result<(), IoError> {
if self.cmd_buffer.len() == self.cmd_buffer.capacity() {
self.cmd_buffer.reserve(1024);
}
// FIXME: don't use a new allocation every time.
let mut cmd_buffer: Vec<u8> = Vec::with_capacity(1024);
let _count = rustix::io::read(fd, spare_capacity(&mut self.cmd_buffer))
let _count = rustix::io::read(fd, spare_capacity(&mut cmd_buffer))
.tap_err(|e| error!("read() on daemon fd {fd:?} failed: {e}"))?;
// So that the loop doesn't borrow from `self`.
let mut cmd_buffer = mem::take(&mut self.cmd_buffer);
// The buffer might have existing data from the last read.
let deserializer = serde_json::Deserializer::from_slice(&cmd_buffer);
let stream: StreamDeserializer<_, DaemonCmd> = deserializer.into_iter();
@ -362,16 +355,13 @@ impl Daemon {
let cmd = match cmd {
Ok(cmd) => cmd,
Err(e) if e.is_eof() => {
self.next_timeout = Some(Duration::from_secs(4));
warn!("Didn't get a valid daemon command; giving the other side 4 seconds...");
let _ = mem::replace(&mut self.cmd_buffer, cmd_buffer);
warn!("Got EOF before a valid command");
debug!("command buffer was: {:?}", cmd_buffer.as_bstr());
return Ok(());
},
Err(e) => {
warn!("error deserializing command: {e}");
debug!("command buffer was: {:?}", cmd_buffer.as_bstr());
cmd_buffer.clear();
let _ = mem::replace(&mut self.cmd_buffer, cmd_buffer);
// Don't propagate the error unless we have too many.
self.fd_error_push(fd.as_raw_fd(), e.into()).tap_err(|e| {
error!("Accumulated too many errors for daemon fd {fd:?}: {e}")
@ -385,9 +375,6 @@ impl Daemon {
self.dispatch_cmd(cmd).unwrap_or_else(|e| todo!("{e}"));
}
cmd_buffer.clear();
let _ = mem::replace(&mut self.cmd_buffer, cmd_buffer);
Ok(())
}
@ -469,25 +456,19 @@ impl Daemon {
}
}
if let Some(timeout) = self.next_timeout {
debug!(
"epoll_wait() with a timeout: {}",
humantime::format_duration(timeout),
);
}
match self.poller.poll(&mut events, self.next_timeout.take()) {
match self.poller.poll(&mut events, TIMEOUT_NEVER) {
Ok(_) => {
trace!(
"mio::Poller::poll() got events: {:?}",
events.iter().size_hint().0,
);
if events.is_empty() {
warn!("timeout expired");
self.cmd_buffer.clear();
} else {
let _ = self.fd_error_pop(self.poller.as_raw_fd());
unreachable!(
"epoll_wait() with a \"forever\" timeout should never give empty events",
);
}
let _ = self.fd_error_pop(self.poller.as_raw_fd());
},
Err(e) if e.kind() == IoErrorKind::Interrupted => {
// EINTR is silly.