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}