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