vasilito/RedBear-OS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

scheme-utils: Merge read_requests and process_requests

Browse Source 
And simplify some matches on the resulting method.
This commit is contained in:
bjorn3
2026-04-15 22:00:52 +02:00
parent 4ef2c7ad6f
commit a5018ca37e
8 changed files with 43 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Cargo.toml
+1 -1
View File
@@ -94,7 +94,7 @@ redox-ioctl = { git = "https://gitlab.redox-os.org/redox-os/relibc.git" }
redox-log = { git = "https://gitlab.redox-os.org/redox-os/redox-log.git" }
redox-rt = { git = "https://gitlab.redox-os.org/redox-os/relibc.git", default-features = false }
redox-scheme = "0.11.0"
redox_syscall = "0.7.4"
redox_syscall = { version = "0.7.4", features = ["std"] }
redox_termios = "0.1.3"
ron = "0.8.1"
serde = { version = "1", features = ["derive"] }
audiod/src/main.rs
+1 -2
View File
@@ -71,10 +71,9 @@ fn daemon(daemon: SchemeDaemon) -> anyhow::Result<()> {
let mut readiness = ReadinessBased::new(&socket, 16);
loop {
if !readiness.read_requests()? {
if !readiness.read_and_process_requests(&mut *scheme.lock().unwrap())? {
break;
}
readiness.process_requests(&mut *scheme.lock().unwrap());
readiness.poll_all_requests(&mut *scheme.lock().unwrap())?;
if !readiness.write_responses()? {
break;
drivers/audio/ac97d/src/main.rs
+1 -2
View File
@@ -112,12 +112,11 @@ fn daemon(daemon: daemon::Daemon, pcid_handle: PciFunctionHandle) -> ! {
}
Source::Scheme => {
if !readiness_based
.read_requests()
.read_and_process_requests(&mut device)
.expect("ac97d: failed to read from socket")
{
break;
}
readiness_based.process_requests(&mut device);
if !readiness_based
.write_responses()
.expect("ac97d: failed to write to socket")
drivers/audio/ihdad/src/main.rs
+1 -2
View File
@@ -117,12 +117,11 @@ fn daemon(daemon: daemon::Daemon, mut pcid_handle: PciFunctionHandle) -> ! {
}
Source::Scheme => {
if !readiness_based
.read_requests()
.read_and_process_requests(&mut device)
.expect("ihdad: failed to read from socket")
{
break;
}
readiness_based.process_requests(&mut device);
if !readiness_based
.write_responses()
.expect("ihdad: failed to write to socket")
drivers/audio/sb16d/src/main.rs
+1 -2
View File
@@ -103,12 +103,11 @@ fn daemon(daemon: daemon::Daemon) -> ! {
}
Source::Scheme => {
if !readiness_based
.read_requests()
.read_and_process_requests(&mut device)
.expect("sb16d: failed to read from socket")
{
break;
}
readiness_based.process_requests(&mut device);
if !readiness_based
.write_responses()
.expect("sb16d: failed to write to socket")
ipcd/src/main.rs
+24 -76
View File
@@ -123,130 +123,78 @@ fn inner(daemon: daemon::Daemon) -> anyhow::Result<()> {
EventSource::ChanSocket => {
// Channel scheme
if !chan_eof {
// 1. Read requests
match chan_handler.read_requests() {
Ok(true) => {} // Read requests success
Ok(false) => {
// EOF
chan_eof = true;
}
Err(err) => return Err(anyhow::anyhow!("{err}")),
// 1. Read and process requests
if !chan_handler.read_and_process_requests(&mut chan)? {
chan_eof = true;
}
}
// 2. Process requests
chan_handler.process_requests(&mut chan);
// 3.Poll all blocking requests
// 2. Poll all blocking requests
chan_handler
.poll_all_requests(&mut chan)
.map_err(|e| anyhow::anyhow!("error occured in poll_all_requests: {e}"))?;
// 3. Write responses
// write_responses returns a Result<bool>, but currently only returns true.
match chan_handler.write_responses() {
Ok(true) => {} // Read requests success
Ok(false) => {
// EOF
chan_eof = true;
}
Err(err) => return Err(anyhow::anyhow!("{err}")),
if !chan_handler.write_responses()? {
chan_eof = true;
}
}
EventSource::ShmSocket => {
// Shared memory scheme
if !shm_eof {
// 1. Read requests
match shm_handler.read_requests() {
Ok(true) => {} // Read requests success
Ok(false) => {
// EOF
shm_eof = true;
}
Err(err) => return Err(anyhow::anyhow!("{err}")),
// 1. Read and process requests
if !shm_handler.read_and_process_requests(&mut shm)? {
shm_eof = true;
}
}
// 2. Process requests
shm_handler.process_requests(&mut shm);
// shm is not a blocking scheme
// 3. Write responses
// 2. Write responses
// write_responses returns a Result<bool>, but currently only returns true.
match shm_handler.write_responses() {
Ok(true) => {} // Read requests success
Ok(false) => {
// EOF
shm_eof = true;
}
Err(err) => return Err(anyhow::anyhow!("{err}")),
if !shm_handler.write_responses()? {
shm_eof = true;
}
}
EventSource::UdsStreamSocket => {
// Unix Domain Socket Stream scheme
if !uds_stream_eof {
// 1. Read requests
match uds_stream_handler.read_requests() {
Ok(true) => {} // Read requests success
Ok(false) => {
// EOF
uds_stream_eof = true;
}
Err(err) => return Err(anyhow::anyhow!("{err}")),
// 1. Read and process requests
if !uds_stream_handler.read_and_process_requests(&mut uds_stream)? {
uds_stream_eof = true;
}
}
// 2. Process requests
uds_stream_handler.process_requests(&mut uds_stream);
// 3.Poll all blocking requests
// 2. Poll all blocking requests
uds_stream_handler
.poll_all_requests(&mut uds_stream)
.map_err(|e| anyhow::anyhow!("error occured in poll_all_requests: {e}"))?;
// 3. Write responses
// write_responses returns a Result<bool>, but currently only returns true.
match uds_stream_handler.write_responses() {
Ok(true) => {} // Read requests success
Ok(false) => {
// EOF
uds_stream_eof = true;
}
Err(err) => return Err(anyhow::anyhow!("{err}")),
if !uds_stream_handler.write_responses()? {
uds_stream_eof = true;
}
}
EventSource::UdsDgramSocket => {
// Unix Domain Socket Dgram scheme
if !uds_dgram_eof {
// 1. Read requests
match uds_dgram_handler.read_requests() {
Ok(true) => {} // Read requests success
Ok(false) => {
// EOF
uds_dgram_eof = true;
}
Err(err) => return Err(anyhow::anyhow!("{err}")),
// 1. Read and process requests
if !uds_dgram_handler.read_and_process_requests(&mut uds_dgram)? {
uds_dgram_eof = true;
}
}
// 2. Process requests
uds_dgram_handler.process_requests(&mut uds_dgram);
// 3.Poll all blocking requests
// 2. Poll all blocking requests
uds_dgram_handler
.poll_all_requests(&mut uds_dgram)
.map_err(|e| anyhow::anyhow!("error occured in poll_all_requests: {e}"))?;
// 3. Write responses
// write_responses returns a Result<bool>, but currently only returns true.
match uds_dgram_handler.write_responses() {
Ok(true) => {} // Read requests success
Ok(false) => {
// EOF
uds_dgram_eof = true;
}
Err(err) => return Err(anyhow::anyhow!("{err}")),
if !uds_dgram_handler.write_responses()? {
uds_dgram_eof = true;
}
}
}
ptyd/src/main.rs
+8 -17
View File
@@ -95,34 +95,25 @@ fn scan_requests(
handler: &mut ReadinessBased<'_>,
scheme: &mut PtyScheme,
) -> libredox::error::Result<()> {
// 1. Read requests
match handler
.read_requests()
// 1. Read and process requests
if !handler
.read_and_process_requests(scheme)
.expect("pty: failed to read from socket")
{
true => {} // Read requests success
false => {
panic!("pty: channel EOF")
}
panic!("pty: channel EOF")
}
// 2. Process requests
handler.process_requests(scheme);
// 3. Poll all blocking requests
// 2. Poll all blocking requests
handler
.poll_all_requests(scheme)
.expect("pty: error occured in poll_all_requests");
// 4. Write responses
match handler
// 3. Write responses
if !handler
.write_responses()
.expect("pty: failed to write to socket")
{
true => {} // Write requests success
false => {
panic!("pty: channel EOF")
}
panic!("pty: channel EOF")
}
Ok(())
}
scheme-utils/src/readiness_based.rs
+6 -5
View File
@@ -31,7 +31,7 @@ impl<'sock> ReadinessBased<'sock> {
state: SchemeState::new(),
}
}
pub fn read_requests(&mut self) -> Result<bool> {
pub fn read_and_process_requests(&mut self, scheme: &mut impl SchemeSync) -> Result<bool> {
assert!(self.requests_read.is_empty());
match self
@@ -39,15 +39,14 @@ impl<'sock> ReadinessBased<'sock> {
.read_requests(&mut self.requests_read, SignalBehavior::Interrupt)
{
// TODO: write ECANCELED or similar for everything in self.states?
Ok(()) if self.requests_read.is_empty() => Ok(false), // EOF
Ok(()) if self.requests_read.is_empty() => return Ok(false), // EOF
Ok(())
| Err(Error {
errno: errno::EINTR | errno::EWOULDBLOCK | errno::EAGAIN,
}) => Ok(true),
}) => {}
Err(err) => return Err(err),
}
}
pub fn process_requests(&mut self, scheme: &mut impl SchemeSync) {
for request in self.requests_read.drain(..) {
let req = match request.kind() {
RequestKind::Call(c) => c,
@@ -113,6 +112,8 @@ impl<'sock> ReadinessBased<'sock> {
};
self.responses_to_write.push_back(resp);
}
Ok(true)
}
// TODO: Doesn't scale. Instead, provide an API for some form of queue.
// TODO: panic if id isn't present?