1 use alloc::{
2     string::String,
3     sync::{Arc, Weak},
4     vec::Vec,
5 };
6 use system_error::SystemError;
7 
8 use crate::{
9     driver::{
10         base::{block::SeekFrom, device::DevicePrivateData},
11         tty::tty_device::TtyFilePrivateData,
12     },
13     filesystem::procfs::ProcfsFilePrivateData,
14     ipc::pipe::{LockedPipeInode, PipeFsPrivateData},
15     kerror,
16     libs::spinlock::SpinLock,
17     net::{
18         event_poll::{EPollItem, EPollPrivateData, EventPoll},
19         socket::SocketInode,
20     },
21     process::ProcessManager,
22 };
23 
24 use super::{Dirent, FileType, IndexNode, InodeId, Metadata, SpecialNodeData};
25 
26 /// 文件私有信息的枚举类型
27 #[derive(Debug, Clone)]
28 #[allow(dead_code)]
29 pub enum FilePrivateData {
30     /// 管道文件私有信息
31     Pipefs(PipeFsPrivateData),
32     /// procfs文件私有信息
33     Procfs(ProcfsFilePrivateData),
34     /// 设备文件的私有信息
35     DevFS(DevicePrivateData),
36     /// tty设备文件的私有信息
37     Tty(TtyFilePrivateData),
38     /// epoll私有信息
39     EPoll(EPollPrivateData),
40     /// 不需要文件私有信息
41     Unused,
42 }
43 
44 impl Default for FilePrivateData {
default() -> Self45     fn default() -> Self {
46         return Self::Unused;
47     }
48 }
49 
50 impl FilePrivateData {
update_mode(&mut self, mode: FileMode)51     pub fn update_mode(&mut self, mode: FileMode) {
52         if let FilePrivateData::Pipefs(pdata) = self {
53             pdata.set_mode(mode);
54         }
55     }
56 }
57 
58 bitflags! {
59     /// @brief 文件打开模式
60     /// 其中，低2bit组合而成的数字的值，用于表示访问权限。其他的bit，才支持通过按位或的方式来表示参数
61     ///
62     /// 与Linux 5.19.10的uapi/asm-generic/fcntl.h相同
63     /// https://code.dragonos.org.cn/xref/linux-5.19.10/tools/include/uapi/asm-generic/fcntl.h#19
64     pub struct FileMode: u32{
65         /* File access modes for `open' and `fcntl'.  */
66         /// Open Read-only
67         const O_RDONLY = 0o0;
68         /// Open Write-only
69         const O_WRONLY = 0o1;
70         /// Open read/write
71         const O_RDWR = 0o2;
72         /// Mask for file access modes
73         const O_ACCMODE = 0o00000003;
74 
75         /* Bits OR'd into the second argument to open.  */
76         /// Create file if it does not exist
77         const O_CREAT = 0o00000100;
78         /// Fail if file already exists
79         const O_EXCL = 0o00000200;
80         /// Do not assign controlling terminal
81         const O_NOCTTY = 0o00000400;
82         /// 文件存在且是普通文件，并以O_RDWR或O_WRONLY打开，则它会被清空
83         const O_TRUNC = 0o00001000;
84         /// 文件指针会被移动到文件末尾
85         const O_APPEND = 0o00002000;
86         /// 非阻塞式IO模式
87         const O_NONBLOCK = 0o00004000;
88         /// 每次write都等待物理I/O完成，但是如果写操作不影响读取刚写入的数据，则不等待文件属性更新
89         const O_DSYNC = 0o00010000;
90         /// fcntl, for BSD compatibility
91         const FASYNC = 0o00020000;
92         /* direct disk access hint */
93         const O_DIRECT = 0o00040000;
94         const O_LARGEFILE = 0o00100000;
95         /// 打开的必须是一个目录
96         const O_DIRECTORY = 0o00200000;
97         /// Do not follow symbolic links
98         const O_NOFOLLOW = 0o00400000;
99         const O_NOATIME = 0o01000000;
100         /// set close_on_exec
101         const O_CLOEXEC = 0o02000000;
102         /// 每次write都等到物理I/O完成，包括write引起的文件属性的更新
103         const O_SYNC = 0o04000000;
104 
105         const O_PATH = 0o10000000;
106 
107         const O_PATH_FLAGS = Self::O_DIRECTORY.bits|Self::O_NOFOLLOW.bits|Self::O_CLOEXEC.bits|Self::O_PATH.bits;
108     }
109 }
110 
111 impl FileMode {
112     /// @brief 获取文件的访问模式的值
113     #[inline]
accmode(&self) -> u32114     pub fn accmode(&self) -> u32 {
115         return self.bits() & FileMode::O_ACCMODE.bits();
116     }
117 }
118 /// @brief 抽象文件结构体
119 #[derive(Debug)]
120 pub struct File {
121     inode: Arc<dyn IndexNode>,
122     /// 对于文件，表示字节偏移量；对于文件夹，表示当前操作的子目录项偏移量
123     offset: usize,
124     /// 文件的打开模式
125     mode: FileMode,
126     /// 文件类型
127     file_type: FileType,
128     /// readdir时候用的，暂存的本次循环中，所有子目录项的名字的数组
129     readdir_subdirs_name: Vec<String>,
130     pub private_data: FilePrivateData,
131 }
132 
133 impl File {
134     /// @brief 创建一个新的文件对象
135     ///
136     /// @param inode 文件对象对应的inode
137     /// @param mode 文件的打开模式
new(inode: Arc<dyn IndexNode>, mode: FileMode) -> Result<Self, SystemError>138     pub fn new(inode: Arc<dyn IndexNode>, mode: FileMode) -> Result<Self, SystemError> {
139         let mut inode = inode;
140         let file_type = inode.metadata()?.file_type;
141         match file_type {
142             FileType::Pipe => {
143                 if let Some(SpecialNodeData::Pipe(pipe_inode)) = inode.special_node() {
144                     inode = pipe_inode;
145                 }
146             }
147             _ => {}
148         }
149 
150         let mut f = File {
151             inode,
152             offset: 0,
153             mode,
154             file_type,
155             readdir_subdirs_name: Vec::new(),
156             private_data: FilePrivateData::default(),
157         };
158         // kdebug!("inode:{:?}",f.inode);
159         f.inode.open(&mut f.private_data, &mode)?;
160 
161         return Ok(f);
162     }
163 
164     /// @brief 从文件中读取指定的字节数到buffer中
165     ///
166     /// @param len 要读取的字节数
167     /// @param buf 目标buffer
168     ///
169     /// @return Ok(usize) 成功读取的字节数
170     /// @return Err(SystemError) 错误码
read(&mut self, len: usize, buf: &mut [u8]) -> Result<usize, SystemError>171     pub fn read(&mut self, len: usize, buf: &mut [u8]) -> Result<usize, SystemError> {
172         self.do_read(self.offset, len, buf, true)
173     }
174 
175     /// @brief 从buffer向文件写入指定的字节数的数据
176     ///
177     /// @param len 要写入的字节数
178     /// @param buf 源数据buffer
179     ///
180     /// @return Ok(usize) 成功写入的字节数
181     /// @return Err(SystemError) 错误码
write(&mut self, len: usize, buf: &[u8]) -> Result<usize, SystemError>182     pub fn write(&mut self, len: usize, buf: &[u8]) -> Result<usize, SystemError> {
183         self.do_write(self.offset, len, buf, true)
184     }
185 
186     /// ## 从文件中指定的偏移处读取指定的字节数到buf中
187     ///
188     /// ### 参数
189     /// - `offset`: 文件偏移量
190     /// - `len`: 要读取的字节数
191     /// - `buf`: 读出缓冲区
192     ///
193     /// ### 返回值
194     /// - `Ok(usize)`: 成功读取的字节数
pread( &mut self, offset: usize, len: usize, buf: &mut [u8], ) -> Result<usize, SystemError>195     pub fn pread(
196         &mut self,
197         offset: usize,
198         len: usize,
199         buf: &mut [u8],
200     ) -> Result<usize, SystemError> {
201         self.do_read(offset, len, buf, false)
202     }
203 
204     /// ## 从buf向文件中指定的偏移处写入指定的字节数的数据
205     ///
206     /// ### 参数
207     /// - `offset`: 文件偏移量
208     /// - `len`: 要写入的字节数
209     /// - `buf`: 写入缓冲区
210     ///
211     /// ### 返回值
212     /// - `Ok(usize)`: 成功写入的字节数
pwrite(&mut self, offset: usize, len: usize, buf: &[u8]) -> Result<usize, SystemError>213     pub fn pwrite(&mut self, offset: usize, len: usize, buf: &[u8]) -> Result<usize, SystemError> {
214         self.do_write(offset, len, buf, false)
215     }
216 
do_read( &mut self, offset: usize, len: usize, buf: &mut [u8], update_offset: bool, ) -> Result<usize, SystemError>217     fn do_read(
218         &mut self,
219         offset: usize,
220         len: usize,
221         buf: &mut [u8],
222         update_offset: bool,
223     ) -> Result<usize, SystemError> {
224         // 先检查本文件在权限等规则下，是否可读取。
225         self.readable()?;
226         if buf.len() < len {
227             return Err(SystemError::ENOBUFS);
228         }
229 
230         let len = self
231             .inode
232             .read_at(offset, len, buf, &mut self.private_data)?;
233 
234         if update_offset {
235             self.offset += len;
236         }
237 
238         Ok(len)
239     }
240 
do_write( &mut self, offset: usize, len: usize, buf: &[u8], update_offset: bool, ) -> Result<usize, SystemError>241     fn do_write(
242         &mut self,
243         offset: usize,
244         len: usize,
245         buf: &[u8],
246         update_offset: bool,
247     ) -> Result<usize, SystemError> {
248         // 先检查本文件在权限等规则下，是否可写入。
249         self.writeable()?;
250         if buf.len() < len {
251             return Err(SystemError::ENOBUFS);
252         }
253 
254         // 如果文件指针已经超过了文件大小，则需要扩展文件大小
255         if offset > self.inode.metadata()?.size as usize {
256             self.inode.resize(offset)?;
257         }
258         let len = self
259             .inode
260             .write_at(offset, len, buf, &mut self.private_data)?;
261 
262         if update_offset {
263             self.offset += len;
264         }
265 
266         Ok(len)
267     }
268 
269     /// @brief 获取文件的元数据
metadata(&self) -> Result<Metadata, SystemError>270     pub fn metadata(&self) -> Result<Metadata, SystemError> {
271         return self.inode.metadata();
272     }
273 
274     /// @brief 根据inode号获取子目录项的名字
275     #[allow(dead_code)]
get_entry_name(&self, ino: InodeId) -> Result<String, SystemError>276     pub fn get_entry_name(&self, ino: InodeId) -> Result<String, SystemError> {
277         return self.inode.get_entry_name(ino);
278     }
279 
280     /// @brief 调整文件操作指针的位置
281     ///
282     /// @param origin 调整的起始位置
lseek(&mut self, origin: SeekFrom) -> Result<usize, SystemError>283     pub fn lseek(&mut self, origin: SeekFrom) -> Result<usize, SystemError> {
284         let file_type = self.inode.metadata()?.file_type;
285         match file_type {
286             FileType::Pipe | FileType::CharDevice => {
287                 return Err(SystemError::ESPIPE);
288             }
289             _ => {}
290         }
291 
292         let pos: i64;
293         match origin {
294             SeekFrom::SeekSet(offset) => {
295                 pos = offset;
296             }
297             SeekFrom::SeekCurrent(offset) => {
298                 pos = self.offset as i64 + offset;
299             }
300             SeekFrom::SeekEnd(offset) => {
301                 let metadata = self.metadata()?;
302                 pos = metadata.size + offset;
303             }
304             SeekFrom::Invalid => {
305                 return Err(SystemError::EINVAL);
306             }
307         }
308         // 根据linux man page, lseek允许超出文件末尾，并且不改变文件大小
309         // 当pos超出文件末尾时，read返回0。直到开始写入数据时，才会改变文件大小
310         if pos < 0 {
311             return Err(SystemError::EOVERFLOW);
312         }
313         self.offset = pos as usize;
314         return Ok(self.offset);
315     }
316 
317     /// @brief 判断当前文件是否可读
318     #[inline]
readable(&self) -> Result<(), SystemError>319     pub fn readable(&self) -> Result<(), SystemError> {
320         // 暂时认为只要不是write only, 就可读
321         if self.mode == FileMode::O_WRONLY {
322             return Err(SystemError::EPERM);
323         }
324 
325         return Ok(());
326     }
327 
328     /// @brief 判断当前文件是否可写
329     #[inline]
writeable(&self) -> Result<(), SystemError>330     pub fn writeable(&self) -> Result<(), SystemError> {
331         // 暂时认为只要不是read only, 就可写
332         if self.mode == FileMode::O_RDONLY {
333             return Err(SystemError::EPERM);
334         }
335 
336         return Ok(());
337     }
338 
339     /// @biref 充填dirent结构体
340     /// @return 返回dirent结构体的大小
readdir(&mut self, dirent: &mut Dirent) -> Result<u64, SystemError>341     pub fn readdir(&mut self, dirent: &mut Dirent) -> Result<u64, SystemError> {
342         let inode: &Arc<dyn IndexNode> = &self.inode;
343 
344         // 如果偏移量为0
345         if self.offset == 0 {
346             // 通过list更新readdir_subdirs_name
347             self.readdir_subdirs_name = inode.list()?;
348             self.readdir_subdirs_name.sort();
349         }
350         // kdebug!("sub_entries={sub_entries:?}");
351 
352         // 已经读到末尾
353         if self.offset == self.readdir_subdirs_name.len() {
354             self.offset = 0;
355             return Ok(0);
356         }
357         let name = &self.readdir_subdirs_name[self.offset];
358         let sub_inode: Arc<dyn IndexNode> = match inode.find(&name) {
359             Ok(i) => i,
360             Err(e) => {
361                 kerror!(
362                     "Readdir error: Failed to find sub inode:{name:?}, file={self:?}, error={e:?}"
363                 );
364                 return Err(e);
365             }
366         };
367 
368         let name_bytes: &[u8] = name.as_bytes();
369 
370         // 根据posix的规定，dirent中的d_name是一个不定长的数组，因此需要unsafe来拷贝数据
371         unsafe {
372             let ptr = &mut dirent.d_name as *mut u8;
373 
374             let buf: &mut [u8] =
375                 ::core::slice::from_raw_parts_mut::<'static, u8>(ptr, name_bytes.len() + 1);
376             buf[0..name_bytes.len()].copy_from_slice(name_bytes);
377             buf[name_bytes.len()] = 0;
378         }
379 
380         self.offset += 1;
381         dirent.d_ino = sub_inode.metadata().unwrap().inode_id.into() as u64;
382         dirent.d_type = sub_inode.metadata().unwrap().file_type.get_file_type_num() as u8;
383 
384         // 计算dirent结构体的大小
385         let size = (name_bytes.len() + ::core::mem::size_of::<Dirent>()
386             - ::core::mem::size_of_val(&dirent.d_name)) as u64;
387 
388         dirent.d_reclen = size as u16;
389         dirent.d_off += dirent.d_reclen as i64;
390 
391         return Ok(size);
392     }
393 
inode(&self) -> Arc<dyn IndexNode>394     pub fn inode(&self) -> Arc<dyn IndexNode> {
395         return self.inode.clone();
396     }
397 
398     /// @brief 尝试克隆一个文件
399     ///
400     /// @return Option<File> 克隆后的文件结构体。如果克隆失败，返回None
try_clone(&self) -> Option<File>401     pub fn try_clone(&self) -> Option<File> {
402         let mut res = Self {
403             inode: self.inode.clone(),
404             offset: self.offset.clone(),
405             mode: self.mode.clone(),
406             file_type: self.file_type.clone(),
407             readdir_subdirs_name: self.readdir_subdirs_name.clone(),
408             private_data: self.private_data.clone(),
409         };
410         // 调用inode的open方法，让inode知道有新的文件打开了这个inode
411         if self.inode.open(&mut res.private_data, &res.mode).is_err() {
412             return None;
413         }
414 
415         return Some(res);
416     }
417 
418     /// @brief 获取文件的类型
419     #[inline]
file_type(&self) -> FileType420     pub fn file_type(&self) -> FileType {
421         return self.file_type;
422     }
423 
424     /// @brief 获取文件的打开模式
425     #[inline]
mode(&self) -> FileMode426     pub fn mode(&self) -> FileMode {
427         return self.mode;
428     }
429 
430     /// 获取文件是否在execve时关闭
431     #[inline]
close_on_exec(&self) -> bool432     pub fn close_on_exec(&self) -> bool {
433         return self.mode.contains(FileMode::O_CLOEXEC);
434     }
435 
436     /// 设置文件是否在execve时关闭
437     #[inline]
set_close_on_exec(&mut self, close_on_exec: bool)438     pub fn set_close_on_exec(&mut self, close_on_exec: bool) {
439         if close_on_exec {
440             self.mode.insert(FileMode::O_CLOEXEC);
441         } else {
442             self.mode.remove(FileMode::O_CLOEXEC);
443         }
444     }
445 
set_mode(&mut self, mode: FileMode) -> Result<(), SystemError>446     pub fn set_mode(&mut self, mode: FileMode) -> Result<(), SystemError> {
447         // todo: 是否需要调用inode的open方法，以更新private data（假如它与mode有关的话）?
448         // 也许需要加个更好的设计，让inode知晓文件的打开模式发生了变化，让它自己决定是否需要更新private data
449 
450         // 直接修改文件的打开模式
451         self.mode = mode;
452         self.private_data.update_mode(mode);
453         return Ok(());
454     }
455 
456     /// @brief 重新设置文件的大小
457     ///
458     /// 如果文件大小增加，则文件内容不变，但是文件的空洞部分会被填充为0
459     /// 如果文件大小减小，则文件内容会被截断
460     ///
461     /// @return 成功：Ok()
462     ///         失败：Err(错误码)
ftruncate(&self, len: usize) -> Result<(), SystemError>463     pub fn ftruncate(&self, len: usize) -> Result<(), SystemError> {
464         // 如果文件不可写，返回错误
465         self.writeable()?;
466 
467         // 调用inode的truncate方法
468         self.inode.resize(len)?;
469         return Ok(());
470     }
471 
472     /// ## 向该文件添加一个EPollItem对象
473     ///
474     /// 在文件状态发生变化时，需要向epoll通知
add_epoll(&mut self, epitem: Arc<EPollItem>) -> Result<(), SystemError>475     pub fn add_epoll(&mut self, epitem: Arc<EPollItem>) -> Result<(), SystemError> {
476         match self.file_type {
477             FileType::Socket => {
478                 let inode = self.inode.downcast_ref::<SocketInode>().unwrap();
479                 let mut socket = inode.inner();
480 
481                 return socket.add_epoll(epitem);
482             }
483             FileType::Pipe => {
484                 let inode = self.inode.downcast_ref::<LockedPipeInode>().unwrap();
485                 return inode.inner().lock().add_epoll(epitem);
486             }
487             _ => {
488                 let r = self.inode.ioctl(
489                     EventPoll::ADD_EPOLLITEM,
490                     &epitem as *const Arc<EPollItem> as usize,
491                     &self.private_data,
492                 );
493                 if r.is_err() {
494                     return Err(SystemError::ENOSYS);
495                 }
496 
497                 Ok(())
498             }
499         }
500     }
501 
502     /// ## 删除一个绑定的epoll
remove_epoll(&mut self, epoll: &Weak<SpinLock<EventPoll>>) -> Result<(), SystemError>503     pub fn remove_epoll(&mut self, epoll: &Weak<SpinLock<EventPoll>>) -> Result<(), SystemError> {
504         match self.file_type {
505             FileType::Socket => {
506                 let inode = self.inode.downcast_ref::<SocketInode>().unwrap();
507                 let mut socket = inode.inner();
508 
509                 return socket.remove_epoll(epoll);
510             }
511             _ => return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP),
512         }
513     }
514 
poll(&self) -> Result<usize, SystemError>515     pub fn poll(&self) -> Result<usize, SystemError> {
516         self.inode.poll(&self.private_data)
517     }
518 }
519 
520 impl Drop for File {
drop(&mut self)521     fn drop(&mut self) {
522         let r: Result<(), SystemError> = self.inode.close(&mut self.private_data);
523         // 打印错误信息
524         if r.is_err() {
525             kerror!(
526                 "pid: {:?} failed to close file: {:?}, errno={:?}",
527                 ProcessManager::current_pcb().pid(),
528                 self,
529                 r.as_ref().unwrap_err()
530             );
531         }
532     }
533 }
534 
535 /// @brief pcb里面的文件描述符数组
536 #[derive(Debug)]
537 pub struct FileDescriptorVec {
538     /// 当前进程打开的文件描述符
539     fds: Vec<Option<Arc<SpinLock<File>>>>,
540 }
541 
542 impl FileDescriptorVec {
543     pub const PROCESS_MAX_FD: usize = 1024;
544 
545     #[inline(never)]
new() -> FileDescriptorVec546     pub fn new() -> FileDescriptorVec {
547         let mut data = Vec::with_capacity(FileDescriptorVec::PROCESS_MAX_FD);
548         data.resize(FileDescriptorVec::PROCESS_MAX_FD, None);
549 
550         // 初始化文件描述符数组结构体
551         return FileDescriptorVec { fds: data };
552     }
553 
554     /// @brief 克隆一个文件描述符数组
555     ///
556     /// @return FileDescriptorVec 克隆后的文件描述符数组
clone(&self) -> FileDescriptorVec557     pub fn clone(&self) -> FileDescriptorVec {
558         let mut res = FileDescriptorVec::new();
559         for i in 0..FileDescriptorVec::PROCESS_MAX_FD {
560             if let Some(file) = &self.fds[i] {
561                 if let Some(file) = file.lock().try_clone() {
562                     res.fds[i] = Some(Arc::new(SpinLock::new(file)));
563                 }
564             }
565         }
566         return res;
567     }
568 
569     /// @brief 判断文件描述符序号是否合法
570     ///
571     /// @return true 合法
572     ///
573     /// @return false 不合法
574     #[inline]
validate_fd(fd: i32) -> bool575     pub fn validate_fd(fd: i32) -> bool {
576         if fd < 0 || fd as usize > FileDescriptorVec::PROCESS_MAX_FD {
577             return false;
578         } else {
579             return true;
580         }
581     }
582 
583     /// 申请文件描述符，并把文件对象存入其中。
584     ///
585     /// ## 参数
586     ///
587     /// - `file` 要存放的文件对象
588     /// - `fd` 如果为Some(i32)，表示指定要申请这个文件描述符，如果这个文件描述符已经被使用，那么返回EBADF
589     ///
590     /// ## 返回值
591     ///
592     /// - `Ok(i32)` 申请成功，返回申请到的文件描述符
593     /// - `Err(SystemError)` 申请失败，返回错误码，并且，file对象将被drop掉
alloc_fd(&mut self, file: File, fd: Option<i32>) -> Result<i32, SystemError>594     pub fn alloc_fd(&mut self, file: File, fd: Option<i32>) -> Result<i32, SystemError> {
595         if fd.is_some() {
596             // 指定了要申请的文件描述符编号
597             let new_fd = fd.unwrap();
598             let x = &mut self.fds[new_fd as usize];
599             if x.is_none() {
600                 *x = Some(Arc::new(SpinLock::new(file)));
601                 return Ok(new_fd);
602             } else {
603                 return Err(SystemError::EBADF);
604             }
605         } else {
606             // 没有指定要申请的文件描述符编号
607             for i in 0..FileDescriptorVec::PROCESS_MAX_FD {
608                 if self.fds[i].is_none() {
609                     self.fds[i] = Some(Arc::new(SpinLock::new(file)));
610                     return Ok(i as i32);
611                 }
612             }
613             return Err(SystemError::EMFILE);
614         }
615     }
616 
617     /// 根据文件描述符序号，获取文件结构体的Arc指针
618     ///
619     /// ## 参数
620     ///
621     /// - `fd` 文件描述符序号
get_file_by_fd(&self, fd: i32) -> Option<Arc<SpinLock<File>>>622     pub fn get_file_by_fd(&self, fd: i32) -> Option<Arc<SpinLock<File>>> {
623         if !FileDescriptorVec::validate_fd(fd) {
624             return None;
625         }
626         return self.fds[fd as usize].clone();
627     }
628 
629     /// 释放文件描述符，同时关闭文件。
630     ///
631     /// ## 参数
632     ///
633     /// - `fd` 文件描述符序号
drop_fd(&mut self, fd: i32) -> Result<(), SystemError>634     pub fn drop_fd(&mut self, fd: i32) -> Result<(), SystemError> {
635         // 判断文件描述符的数字是否超过限制
636         if !FileDescriptorVec::validate_fd(fd) {
637             return Err(SystemError::EBADF);
638         }
639 
640         self.get_file_by_fd(fd).ok_or(SystemError::EBADF)?;
641 
642         // 把文件描述符数组对应位置设置为空
643         let file = self.fds[fd as usize].take().unwrap();
644 
645         assert!(Arc::strong_count(&file) == 1);
646         return Ok(());
647     }
648 
649     #[allow(dead_code)]
iter(&self) -> FileDescriptorIterator650     pub fn iter(&self) -> FileDescriptorIterator {
651         return FileDescriptorIterator::new(self);
652     }
653 
close_on_exec(&mut self)654     pub fn close_on_exec(&mut self) {
655         for i in 0..FileDescriptorVec::PROCESS_MAX_FD {
656             if let Some(file) = &self.fds[i] {
657                 let to_drop = file.lock().close_on_exec();
658                 if to_drop {
659                     if let Err(r) = self.drop_fd(i as i32) {
660                         kerror!(
661                             "Failed to close file: pid = {:?}, fd = {}, error = {:?}",
662                             ProcessManager::current_pcb().pid(),
663                             i,
664                             r
665                         );
666                     }
667                 }
668             }
669         }
670     }
671 }
672 
673 #[derive(Debug)]
674 pub struct FileDescriptorIterator<'a> {
675     fds: &'a FileDescriptorVec,
676     index: usize,
677 }
678 
679 impl<'a> FileDescriptorIterator<'a> {
new(fds: &'a FileDescriptorVec) -> Self680     pub fn new(fds: &'a FileDescriptorVec) -> Self {
681         return Self { fds, index: 0 };
682     }
683 }
684 
685 impl<'a> Iterator for FileDescriptorIterator<'a> {
686     type Item = (i32, Arc<SpinLock<File>>);
687 
next(&mut self) -> Option<Self::Item>688     fn next(&mut self) -> Option<Self::Item> {
689         while self.index < FileDescriptorVec::PROCESS_MAX_FD {
690             let fd = self.index as i32;
691             self.index += 1;
692             if let Some(file) = self.fds.get_file_by_fd(fd) {
693                 return Some((fd, file));
694             }
695         }
696         return None;
697     }
698 }
699