xref: /DragonOS/kernel/src/ipc/pipe.rs (revision 11110997465e858757da54b5ce28d7c22690aaff) 
1 use crate::{
2     arch::{sched::sched, CurrentIrqArch},
3     exception::InterruptArch,
4     filesystem::vfs::{
5         core::generate_inode_id, file::FileMode, FilePrivateData, FileSystem, FileType, IndexNode,
6         Metadata, PollStatus,
7     },
8     libs::{spinlock::SpinLock, wait_queue::WaitQueue},
9     process::ProcessState,
10     syscall::SystemError,
11     time::TimeSpec,
12 };
13 
14 use alloc::sync::{Arc, Weak};
15 
16 /// 我们设定pipe_buff的总大小为1024字节
17 const PIPE_BUFF_SIZE: usize = 1024;
18 
19 /// @brief 管道文件i节点(锁)
20 #[derive(Debug)]
21 pub struct LockedPipeInode(SpinLock<InnerPipeInode>);
22 
23 /// @brief 管道文件i节点(无锁)
24 #[derive(Debug)]
25 pub struct InnerPipeInode {
26     self_ref: Weak<LockedPipeInode>,
27     valid_cnt: i32,
28     read_pos: i32,
29     write_pos: i32,
30     read_wait_queue: WaitQueue,
31     write_wait_queue: WaitQueue,
32     data: [u8; PIPE_BUFF_SIZE],
33     /// INode 元数据
34     metadata: Metadata,
35     flags: FileMode,
36 }
37 
38 impl LockedPipeInode {
39     pub fn new(flags: FileMode) -> Arc<Self> {
40         let inner = InnerPipeInode {
41             self_ref: Weak::default(),
42             valid_cnt: 0,
43             read_pos: 0,
44             write_pos: 0,
45             read_wait_queue: WaitQueue::INIT,
46             write_wait_queue: WaitQueue::INIT,
47             data: [0; PIPE_BUFF_SIZE],
48 
49             metadata: Metadata {
50                 dev_id: 0,
51                 inode_id: generate_inode_id(),
52                 size: PIPE_BUFF_SIZE as i64,
53                 blk_size: 0,
54                 blocks: 0,
55                 atime: TimeSpec::default(),
56                 mtime: TimeSpec::default(),
57                 ctime: TimeSpec::default(),
58                 file_type: FileType::Pipe,
59                 mode: 0o666,
60                 nlinks: 1,
61                 uid: 0,
62                 gid: 0,
63                 raw_dev: 0,
64             },
65             flags,
66         };
67         let result = Arc::new(Self(SpinLock::new(inner)));
68         let mut guard = result.0.lock();
69         guard.self_ref = Arc::downgrade(&result);
70         // 释放锁
71         drop(guard); //这一步其实不需要，只要离开作用域，guard生命周期结束，自会解锁
72         return result;
73     }
74 }
75 
76 impl IndexNode for LockedPipeInode {
77     fn read_at(
78         &self,
79         _offset: usize,
80         len: usize,
81         buf: &mut [u8],
82         _data: &mut FilePrivateData,
83     ) -> Result<usize, crate::syscall::SystemError> {
84         if buf.len() < len {
85             return Err(SystemError::EINVAL);
86         }
87         // 加锁
88         let mut inode = self.0.lock();
89 
90         // 如果管道里面没有数据，则唤醒写端，
91         while inode.valid_cnt == 0 {
92             inode
93                 .write_wait_queue
94                 .wakeup(Some(ProcessState::Blocked(true)));
95 
96             // 如果为非阻塞管道，直接返回错误
97             if inode.flags.contains(FileMode::O_NONBLOCK) {
98                 drop(inode);
99                 return Err(SystemError::EAGAIN_OR_EWOULDBLOCK);
100             }
101 
102             // 否则在读等待队列中睡眠，并释放锁
103             unsafe {
104                 let irq_guard = CurrentIrqArch::save_and_disable_irq();
105                 inode.read_wait_queue.sleep_without_schedule();
106                 drop(inode);
107 
108                 drop(irq_guard);
109             }
110             sched();
111             inode = self.0.lock();
112         }
113 
114         let mut num = inode.valid_cnt as usize;
115         //决定要输出的字节
116         let start = inode.read_pos as usize;
117         //如果读端希望读取的字节数大于有效字节数，则输出有效字节
118         let mut end = (inode.valid_cnt as usize + inode.read_pos as usize) % PIPE_BUFF_SIZE;
119         //如果读端希望读取的字节数少于有效字节数，则输出希望读取的字节
120         if len < inode.valid_cnt as usize {
121             end = (len + inode.read_pos as usize) % PIPE_BUFF_SIZE;
122             num = len;
123         }
124 
125         // 从管道拷贝数据到用户的缓冲区
126 
127         if end < start {
128             buf[0..(PIPE_BUFF_SIZE - start)].copy_from_slice(&inode.data[start..PIPE_BUFF_SIZE]);
129             buf[(PIPE_BUFF_SIZE - start)..num].copy_from_slice(&inode.data[0..end]);
130         } else {
131             buf[0..num].copy_from_slice(&inode.data[start..end]);
132         }
133 
134         //更新读位置以及valid_cnt
135         inode.read_pos = (inode.read_pos + num as i32) % PIPE_BUFF_SIZE as i32;
136         inode.valid_cnt -= num as i32;
137 
138         //读完后解锁并唤醒等待在写等待队列中的进程
139         inode
140             .write_wait_queue
141             .wakeup(Some(ProcessState::Blocked(true)));
142         //返回读取的字节数
143         return Ok(num);
144     }
145 
146     fn open(
147         &self,
148         _data: &mut FilePrivateData,
149         _mode: &crate::filesystem::vfs::file::FileMode,
150     ) -> Result<(), SystemError> {
151         return Ok(());
152     }
153 
154     fn metadata(&self) -> Result<crate::filesystem::vfs::Metadata, SystemError> {
155         let inode = self.0.lock();
156         let mut metadata = inode.metadata.clone();
157         metadata.size = inode.data.len() as i64;
158 
159         return Ok(metadata);
160     }
161 
162     fn close(&self, _data: &mut FilePrivateData) -> Result<(), SystemError> {
163         return Ok(());
164     }
165 
166     fn write_at(
167         &self,
168         _offset: usize,
169         len: usize,
170         buf: &[u8],
171         _data: &mut FilePrivateData,
172     ) -> Result<usize, crate::syscall::SystemError> {
173         if buf.len() < len || len > PIPE_BUFF_SIZE {
174             return Err(SystemError::EINVAL);
175         }
176         // 加锁
177 
178         let mut inode = self.0.lock();
179 
180         // 如果管道空间不够
181 
182         while len + inode.valid_cnt as usize > PIPE_BUFF_SIZE {
183             // 唤醒读端
184             inode
185                 .read_wait_queue
186                 .wakeup(Some(ProcessState::Blocked(true)));
187 
188             // 如果为非阻塞管道，直接返回错误
189             if inode.flags.contains(FileMode::O_NONBLOCK) {
190                 drop(inode);
191                 return Err(SystemError::ENOMEM);
192             }
193 
194             // 解锁并睡眠
195             unsafe {
196                 let irq_guard = CurrentIrqArch::save_and_disable_irq();
197                 inode.write_wait_queue.sleep_without_schedule();
198                 drop(inode);
199                 drop(irq_guard);
200             }
201             sched();
202             inode = self.0.lock();
203         }
204 
205         // 决定要输入的字节
206         let start = inode.write_pos as usize;
207         let end = (inode.write_pos as usize + len) % PIPE_BUFF_SIZE;
208         // 从用户的缓冲区拷贝数据到管道
209 
210         if end < start {
211             inode.data[start..PIPE_BUFF_SIZE].copy_from_slice(&buf[0..(PIPE_BUFF_SIZE - start)]);
212             inode.data[0..end].copy_from_slice(&buf[(PIPE_BUFF_SIZE - start)..len]);
213         } else {
214             inode.data[start..end].copy_from_slice(&buf[0..len]);
215         }
216         // 更新写位置以及valid_cnt
217         inode.write_pos = (inode.write_pos + len as i32) % PIPE_BUFF_SIZE as i32;
218         inode.valid_cnt += len as i32;
219 
220         // 读完后解锁并唤醒等待在读等待队列中的进程
221         inode
222             .read_wait_queue
223             .wakeup(Some(ProcessState::Blocked(true)));
224         // 返回写入的字节数
225         return Ok(len);
226     }
227 
228     fn poll(&self) -> Result<PollStatus, crate::syscall::SystemError> {
229         return Ok(PollStatus::READ | PollStatus::WRITE);
230     }
231 
232     fn as_any_ref(&self) -> &dyn core::any::Any {
233         self
234     }
235 
236     fn get_entry_name_and_metadata(
237         &self,
238         ino: crate::filesystem::vfs::InodeId,
239     ) -> Result<(alloc::string::String, crate::filesystem::vfs::Metadata), SystemError> {
240         // 如果有条件，请在文件系统中使用高效的方式实现本接口，而不是依赖这个低效率的默认实现。
241         let name = self.get_entry_name(ino)?;
242         let entry = self.find(&name)?;
243         return Ok((name, entry.metadata()?));
244     }
245 
246     fn fs(&self) -> Arc<(dyn FileSystem)> {
247         todo!()
248     }
249 
250     fn list(&self) -> Result<alloc::vec::Vec<alloc::string::String>, SystemError> {
251         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
252     }
253 }
254