Skip to main content

ahrightos_fs/
pipe.rs

1use crate::file::{File, FileError};
2use alloc::sync::Arc;
3use spin::Mutex;
4
5pub const PIPE_BUFFER_SIZE: usize = 4096;
6
7pub(crate) struct PipeInner {
8    buf: [u8; PIPE_BUFFER_SIZE],
9    read_pos: usize,
10    write_pos: usize,
11    count: usize,
12    write_closed: bool,
13    read_closed: bool,
14}
15
16impl PipeInner {
17    fn new() -> Self {
18        Self {
19            buf: [0u8; PIPE_BUFFER_SIZE],
20            read_pos: 0,
21            write_pos: 0,
22            count: 0,
23            write_closed: false,
24            read_closed: false,
25        }
26    }
27}
28
29pub(crate) type PipeHandle = Arc<Mutex<PipeInner>>;
30
31pub fn make_pipe() -> (PipeReadEnd, PipeWriteEnd) {
32    let inner = Arc::new(Mutex::new(PipeInner::new()));
33    (
34        PipeReadEnd {
35            inner: inner.clone(),
36        },
37        PipeWriteEnd { inner },
38    )
39}
40
41pub struct PipeReadEnd {
42    inner: PipeHandle,
43}
44
45impl File for PipeReadEnd {
46    fn read(&mut self, buf: &mut [u8]) -> Result<usize, FileError> {
47        let mut p = self.inner.lock();
48        if p.count == 0 {
49            return if p.write_closed {
50                Ok(0)
51            } else {
52                Err(FileError::WouldBlock)
53            };
54        }
55        let n = core::cmp::min(buf.len(), p.count);
56        for slot in buf.iter_mut().take(n) {
57            *slot = p.buf[p.read_pos];
58            p.read_pos = (p.read_pos + 1) % PIPE_BUFFER_SIZE;
59        }
60        p.count -= n;
61        Ok(n)
62    }
63
64    fn write(&mut self, _buf: &[u8]) -> Result<usize, FileError> {
65        Err(FileError::InvalidOperation)
66    }
67}
68
69impl Drop for PipeReadEnd {
70    fn drop(&mut self) {
71        self.inner.lock().read_closed = true;
72    }
73}
74
75pub struct PipeWriteEnd {
76    inner: PipeHandle,
77}
78
79impl File for PipeWriteEnd {
80    fn read(&mut self, _buf: &mut [u8]) -> Result<usize, FileError> {
81        Err(FileError::InvalidOperation)
82    }
83
84    fn write(&mut self, buf: &[u8]) -> Result<usize, FileError> {
85        let mut p = self.inner.lock();
86        if p.read_closed {
87            return Err(FileError::IoError);
88        }
89        let free = PIPE_BUFFER_SIZE - p.count;
90        let n = core::cmp::min(buf.len(), free);
91        if n == 0 && !buf.is_empty() {
92            return Err(FileError::WouldBlock);
93        }
94        for &byte in buf.iter().take(n) {
95            let pos = p.write_pos;
96            p.buf[pos] = byte;
97            p.write_pos = (pos + 1) % PIPE_BUFFER_SIZE;
98        }
99        p.count += n;
100        Ok(n)
101    }
102}
103
104impl Drop for PipeWriteEnd {
105    fn drop(&mut self) {
106        self.inner.lock().write_closed = true;
107    }
108}
109
110#[cfg(test)]
111mod tests {
112    use super::*;
113
114    #[test]
115    fn pipe_round_trips_bytes() {
116        let (mut read_end, mut write_end) = make_pipe();
117        assert_eq!(write_end.write(b"abc").unwrap(), 3);
118        let mut buf = [0; 4];
119        assert_eq!(read_end.read(&mut buf).unwrap(), 3);
120        assert_eq!(&buf[..3], b"abc");
121    }
122}