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