1 use core::sync::atomic::{AtomicUsize, Ordering}; 2 3 use alloc::{ 4 string::String, 5 sync::{Arc, Weak}, 6 vec::Vec, 7 }; 8 use system_error::SystemError; 9 10 use crate::{ 11 driver::{ 12 base::{block::SeekFrom, device::DevicePrivateData}, 13 tty::tty_device::TtyFilePrivateData, 14 }, 15 filesystem::procfs::ProcfsFilePrivateData, 16 ipc::pipe::{LockedPipeInode, PipeFsPrivateData}, 17 kerror, 18 libs::{rwlock::RwLock, spinlock::SpinLock}, 19 net::{ 20 event_poll::{EPollItem, EPollPrivateData, EventPoll}, 21 socket::SocketInode, 22 }, 23 process::ProcessManager, 24 }; 25 26 use super::{Dirent, FileType, IndexNode, InodeId, Metadata, SpecialNodeData}; 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 136 impl File { 137 /// @brief 创建一个新的文件对象 138 /// 139 /// @param inode 文件对象对应的inode 140 /// @param mode 文件的打开模式 141 pub fn new(inode: Arc<dyn IndexNode>, mode: FileMode) -> Result<Self, SystemError> { 142 let mut inode = inode; 143 let file_type = inode.metadata()?.file_type; 144 if file_type == FileType::Pipe { 145 if let Some(SpecialNodeData::Pipe(pipe_inode)) = inode.special_node() { 146 inode = pipe_inode; 147 } 148 } 149 150 let f = File { 151 inode, 152 offset: AtomicUsize::new(0), 153 mode: RwLock::new(mode), 154 file_type, 155 readdir_subdirs_name: SpinLock::new(Vec::default()), 156 private_data: SpinLock::new(FilePrivateData::default()), 157 }; 158 // kdebug!("inode:{:?}",f.inode); 159 f.inode.open(f.private_data.lock(), &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) 错误码 171 pub fn read(&self, len: usize, buf: &mut [u8]) -> Result<usize, SystemError> { 172 self.do_read( 173 self.offset.load(core::sync::atomic::Ordering::SeqCst), 174 len, 175 buf, 176 true, 177 ) 178 } 179 180 /// @brief 从buffer向文件写入指定的字节数的数据 181 /// 182 /// @param len 要写入的字节数 183 /// @param buf 源数据buffer 184 /// 185 /// @return Ok(usize) 成功写入的字节数 186 /// @return Err(SystemError) 错误码 187 pub fn write(&self, len: usize, buf: &[u8]) -> Result<usize, SystemError> { 188 self.do_write( 189 self.offset.load(core::sync::atomic::Ordering::SeqCst), 190 len, 191 buf, 192 true, 193 ) 194 } 195 196 /// ## 从文件中指定的偏移处读取指定的字节数到buf中 197 /// 198 /// ### 参数 199 /// - `offset`: 文件偏移量 200 /// - `len`: 要读取的字节数 201 /// - `buf`: 读出缓冲区 202 /// 203 /// ### 返回值 204 /// - `Ok(usize)`: 成功读取的字节数 205 pub fn pread(&self, offset: usize, len: usize, buf: &mut [u8]) -> Result<usize, SystemError> { 206 self.do_read(offset, len, buf, false) 207 } 208 209 /// ## 从buf向文件中指定的偏移处写入指定的字节数的数据 210 /// 211 /// ### 参数 212 /// - `offset`: 文件偏移量 213 /// - `len`: 要写入的字节数 214 /// - `buf`: 写入缓冲区 215 /// 216 /// ### 返回值 217 /// - `Ok(usize)`: 成功写入的字节数 218 pub fn pwrite(&self, offset: usize, len: usize, buf: &[u8]) -> Result<usize, SystemError> { 219 self.do_write(offset, len, buf, false) 220 } 221 222 fn do_read( 223 &self, 224 offset: usize, 225 len: usize, 226 buf: &mut [u8], 227 update_offset: bool, 228 ) -> Result<usize, SystemError> { 229 // 先检查本文件在权限等规则下，是否可读取。 230 self.readable()?; 231 if buf.len() < len { 232 return Err(SystemError::ENOBUFS); 233 } 234 235 let len = self 236 .inode 237 .read_at(offset, len, buf, self.private_data.lock())?; 238 239 if update_offset { 240 self.offset 241 .fetch_add(len, core::sync::atomic::Ordering::SeqCst); 242 } 243 244 Ok(len) 245 } 246 247 fn do_write( 248 &self, 249 offset: usize, 250 len: usize, 251 buf: &[u8], 252 update_offset: bool, 253 ) -> Result<usize, SystemError> { 254 // 先检查本文件在权限等规则下，是否可写入。 255 self.writeable()?; 256 if buf.len() < len { 257 return Err(SystemError::ENOBUFS); 258 } 259 260 // 如果文件指针已经超过了文件大小，则需要扩展文件大小 261 if offset > self.inode.metadata()?.size as usize { 262 self.inode.resize(offset)?; 263 } 264 let len = self 265 .inode 266 .write_at(offset, len, buf, self.private_data.lock())?; 267 268 if update_offset { 269 self.offset 270 .fetch_add(len, core::sync::atomic::Ordering::SeqCst); 271 } 272 273 Ok(len) 274 } 275 276 /// @brief 获取文件的元数据 277 pub fn metadata(&self) -> Result<Metadata, SystemError> { 278 return self.inode.metadata(); 279 } 280 281 /// @brief 根据inode号获取子目录项的名字 282 #[allow(dead_code)] 283 pub fn get_entry_name(&self, ino: InodeId) -> Result<String, SystemError> { 284 return self.inode.get_entry_name(ino); 285 } 286 287 /// @brief 调整文件操作指针的位置 288 /// 289 /// @param origin 调整的起始位置 290 pub fn lseek(&self, origin: SeekFrom) -> Result<usize, SystemError> { 291 let file_type = self.inode.metadata()?.file_type; 292 match file_type { 293 FileType::Pipe | FileType::CharDevice => { 294 return Err(SystemError::ESPIPE); 295 } 296 _ => {} 297 } 298 299 let pos: i64 = match origin { 300 SeekFrom::SeekSet(offset) => offset, 301 SeekFrom::SeekCurrent(offset) => self.offset.load(Ordering::SeqCst) as i64 + offset, 302 SeekFrom::SeekEnd(offset) => { 303 let metadata = self.metadata()?; 304 metadata.size + offset 305 } 306 SeekFrom::Invalid => { 307 return Err(SystemError::EINVAL); 308 } 309 }; 310 // 根据linux man page, lseek允许超出文件末尾，并且不改变文件大小 311 // 当pos超出文件末尾时，read返回0。直到开始写入数据时，才会改变文件大小 312 if pos < 0 { 313 return Err(SystemError::EOVERFLOW); 314 } 315 self.offset.store(pos as usize, Ordering::SeqCst); 316 return Ok(pos as usize); 317 } 318 319 /// @brief 判断当前文件是否可读 320 #[inline] 321 pub fn readable(&self) -> Result<(), SystemError> { 322 // 暂时认为只要不是write only, 就可读 323 if *self.mode.read() == FileMode::O_WRONLY { 324 return Err(SystemError::EPERM); 325 } 326 327 return Ok(()); 328 } 329 330 /// @brief 判断当前文件是否可写 331 #[inline] 332 pub fn writeable(&self) -> Result<(), SystemError> { 333 // 暂时认为只要不是read only, 就可写 334 if *self.mode.read() == FileMode::O_RDONLY { 335 return Err(SystemError::EPERM); 336 } 337 338 return Ok(()); 339 } 340 341 /// @biref 充填dirent结构体 342 /// @return 返回dirent结构体的大小 343 pub fn readdir(&self, dirent: &mut Dirent) -> Result<u64, SystemError> { 344 let inode: &Arc<dyn IndexNode> = &self.inode; 345 let mut readdir_subdirs_name = self.readdir_subdirs_name.lock(); 346 let offset = self.offset.load(Ordering::SeqCst); 347 // 如果偏移量为0 348 if offset == 0 { 349 // 通过list更新readdir_subdirs_name 350 *readdir_subdirs_name = inode.list()?; 351 readdir_subdirs_name.sort(); 352 } 353 // kdebug!("sub_entries={sub_entries:?}"); 354 355 // 已经读到末尾 356 if offset == readdir_subdirs_name.len() { 357 self.offset.store(0, Ordering::SeqCst); 358 return Ok(0); 359 } 360 let name = &readdir_subdirs_name[offset]; 361 let sub_inode: Arc<dyn IndexNode> = match inode.find(name) { 362 Ok(i) => i, 363 Err(e) => { 364 kerror!( 365 "Readdir error: Failed to find sub inode:{name:?}, file={self:?}, error={e:?}" 366 ); 367 return Err(e); 368 } 369 }; 370 371 let name_bytes: &[u8] = name.as_bytes(); 372 373 // 根据posix的规定，dirent中的d_name是一个不定长的数组，因此需要unsafe来拷贝数据 374 unsafe { 375 let ptr = &mut dirent.d_name as *mut u8; 376 377 let buf: &mut [u8] = 378 ::core::slice::from_raw_parts_mut::<'static, u8>(ptr, name_bytes.len() + 1); 379 buf[0..name_bytes.len()].copy_from_slice(name_bytes); 380 buf[name_bytes.len()] = 0; 381 } 382 383 self.offset.fetch_add(1, Ordering::SeqCst); 384 dirent.d_ino = sub_inode.metadata().unwrap().inode_id.into() as u64; 385 dirent.d_type = sub_inode.metadata().unwrap().file_type.get_file_type_num() as u8; 386 387 // 计算dirent结构体的大小 388 let size = (name_bytes.len() + ::core::mem::size_of::<Dirent>() 389 - ::core::mem::size_of_val(&dirent.d_name)) as u64; 390 391 dirent.d_reclen = size as u16; 392 dirent.d_off += dirent.d_reclen as i64; 393 394 return Ok(size); 395 } 396 397 pub fn inode(&self) -> Arc<dyn IndexNode> { 398 return self.inode.clone(); 399 } 400 401 /// @brief 尝试克隆一个文件 402 /// 403 /// @return Option<File> 克隆后的文件结构体。如果克隆失败，返回None 404 pub fn try_clone(&self) -> Option<File> { 405 let res = Self { 406 inode: self.inode.clone(), 407 offset: AtomicUsize::new(self.offset.load(Ordering::SeqCst)), 408 mode: RwLock::new(self.mode()), 409 file_type: self.file_type, 410 readdir_subdirs_name: SpinLock::new(self.readdir_subdirs_name.lock().clone()), 411 private_data: SpinLock::new(self.private_data.lock().clone()), 412 }; 413 // 调用inode的open方法，让inode知道有新的文件打开了这个inode 414 if self 415 .inode 416 .open(res.private_data.lock(), &res.mode()) 417 .is_err() 418 { 419 return None; 420 } 421 422 return Some(res); 423 } 424 425 /// @brief 获取文件的类型 426 #[inline] 427 pub fn file_type(&self) -> FileType { 428 return self.file_type; 429 } 430 431 /// @brief 获取文件的打开模式 432 #[inline] 433 pub fn mode(&self) -> FileMode { 434 return *self.mode.read(); 435 } 436 437 /// 获取文件是否在execve时关闭 438 #[inline] 439 pub fn close_on_exec(&self) -> bool { 440 return self.mode().contains(FileMode::O_CLOEXEC); 441 } 442 443 /// 设置文件是否在execve时关闭 444 #[inline] 445 pub fn set_close_on_exec(&self, close_on_exec: bool) { 446 let mut mode_guard = self.mode.write(); 447 if close_on_exec { 448 mode_guard.insert(FileMode::O_CLOEXEC); 449 } else { 450 mode_guard.remove(FileMode::O_CLOEXEC); 451 } 452 } 453 454 pub fn set_mode(&self, mode: FileMode) -> Result<(), SystemError> { 455 // todo: 是否需要调用inode的open方法，以更新private data（假如它与mode有关的话）? 456 // 也许需要加个更好的设计，让inode知晓文件的打开模式发生了变化，让它自己决定是否需要更新private data 457 458 // 直接修改文件的打开模式 459 *self.mode.write() = mode; 460 self.private_data.lock().update_mode(mode); 461 return Ok(()); 462 } 463 464 /// @brief 重新设置文件的大小 465 /// 466 /// 如果文件大小增加，则文件内容不变，但是文件的空洞部分会被填充为0 467 /// 如果文件大小减小，则文件内容会被截断 468 /// 469 /// @return 成功：Ok() 470 /// 失败：Err(错误码) 471 pub fn ftruncate(&self, len: usize) -> Result<(), SystemError> { 472 // 如果文件不可写，返回错误 473 self.writeable()?; 474 475 // 调用inode的truncate方法 476 self.inode.resize(len)?; 477 return Ok(()); 478 } 479 480 /// ## 向该文件添加一个EPollItem对象 481 /// 482 /// 在文件状态发生变化时，需要向epoll通知 483 pub fn add_epoll(&self, epitem: Arc<EPollItem>) -> Result<(), SystemError> { 484 match self.file_type { 485 FileType::Socket => { 486 let inode = self.inode.downcast_ref::<SocketInode>().unwrap(); 487 let mut socket = inode.inner(); 488 489 return socket.add_epoll(epitem); 490 } 491 FileType::Pipe => { 492 let inode = self.inode.downcast_ref::<LockedPipeInode>().unwrap(); 493 return inode.inner().lock().add_epoll(epitem); 494 } 495 _ => { 496 let r = self.inode.ioctl( 497 EventPoll::ADD_EPOLLITEM, 498 &epitem as *const Arc<EPollItem> as usize, 499 &self.private_data.lock(), 500 ); 501 if r.is_err() { 502 return Err(SystemError::ENOSYS); 503 } 504 505 Ok(()) 506 } 507 } 508 } 509 510 /// ## 删除一个绑定的epoll 511 pub fn remove_epoll(&self, epoll: &Weak<SpinLock<EventPoll>>) -> Result<(), SystemError> { 512 match self.file_type { 513 FileType::Socket => { 514 let inode = self.inode.downcast_ref::<SocketInode>().unwrap(); 515 let mut socket = inode.inner(); 516 517 return socket.remove_epoll(epoll); 518 } 519 _ => return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP), 520 } 521 } 522 523 pub fn poll(&self) -> Result<usize, SystemError> { 524 self.inode.poll(&self.private_data.lock()) 525 } 526 } 527 528 impl Drop for File { 529 fn drop(&mut self) { 530 let r: Result<(), SystemError> = self.inode.close(self.private_data.lock()); 531 // 打印错误信息 532 if r.is_err() { 533 kerror!( 534 "pid: {:?} failed to close file: {:?}, errno={:?}", 535 ProcessManager::current_pcb().pid(), 536 self, 537 r.as_ref().unwrap_err() 538 ); 539 } 540 } 541 } 542 543 /// @brief pcb里面的文件描述符数组 544 #[derive(Debug)] 545 pub struct FileDescriptorVec { 546 /// 当前进程打开的文件描述符 547 fds: Vec<Option<Arc<File>>>, 548 } 549 550 impl FileDescriptorVec { 551 pub const PROCESS_MAX_FD: usize = 1024; 552 553 #[inline(never)] 554 pub fn new() -> FileDescriptorVec { 555 let mut data = Vec::with_capacity(FileDescriptorVec::PROCESS_MAX_FD); 556 data.resize(FileDescriptorVec::PROCESS_MAX_FD, None); 557 558 // 初始化文件描述符数组结构体 559 return FileDescriptorVec { fds: data }; 560 } 561 562 /// @brief 克隆一个文件描述符数组 563 /// 564 /// @return FileDescriptorVec 克隆后的文件描述符数组 565 pub fn clone(&self) -> FileDescriptorVec { 566 let mut res = FileDescriptorVec::new(); 567 for i in 0..FileDescriptorVec::PROCESS_MAX_FD { 568 if let Some(file) = &self.fds[i] { 569 if let Some(file) = file.try_clone() { 570 res.fds[i] = Some(Arc::new(file)); 571 } 572 } 573 } 574 return res; 575 } 576 577 /// @brief 判断文件描述符序号是否合法 578 /// 579 /// @return true 合法 580 /// 581 /// @return false 不合法 582 #[inline] 583 pub fn validate_fd(fd: i32) -> bool { 584 return !(fd < 0 || fd as usize > FileDescriptorVec::PROCESS_MAX_FD); 585 } 586 587 /// 申请文件描述符，并把文件对象存入其中。 588 /// 589 /// ## 参数 590 /// 591 /// - `file` 要存放的文件对象 592 /// - `fd` 如果为Some(i32)，表示指定要申请这个文件描述符，如果这个文件描述符已经被使用，那么返回EBADF 593 /// 594 /// ## 返回值 595 /// 596 /// - `Ok(i32)` 申请成功，返回申请到的文件描述符 597 /// - `Err(SystemError)` 申请失败，返回错误码，并且，file对象将被drop掉 598 pub fn alloc_fd(&mut self, file: File, fd: Option<i32>) -> Result<i32, SystemError> { 599 if let Some(new_fd) = fd { 600 let x = &mut self.fds[new_fd as usize]; 601 if x.is_none() { 602 *x = Some(Arc::new(file)); 603 return Ok(new_fd); 604 } else { 605 return Err(SystemError::EBADF); 606 } 607 } else { 608 // 没有指定要申请的文件描述符编号 609 for i in 0..FileDescriptorVec::PROCESS_MAX_FD { 610 if self.fds[i].is_none() { 611 self.fds[i] = Some(Arc::new(file)); 612 return Ok(i as i32); 613 } 614 } 615 return Err(SystemError::EMFILE); 616 } 617 } 618 619 /// 根据文件描述符序号，获取文件结构体的Arc指针 620 /// 621 /// ## 参数 622 /// 623 /// - `fd` 文件描述符序号 624 pub fn get_file_by_fd(&self, fd: i32) -> Option<Arc<File>> { 625 if !FileDescriptorVec::validate_fd(fd) { 626 return None; 627 } 628 self.fds[fd as usize].clone() 629 } 630 631 /// 释放文件描述符，同时关闭文件。 632 /// 633 /// ## 参数 634 /// 635 /// - `fd` 文件描述符序号 636 pub fn drop_fd(&mut self, fd: i32) -> Result<(), SystemError> { 637 // 判断文件描述符的数字是否超过限制 638 if !FileDescriptorVec::validate_fd(fd) { 639 return Err(SystemError::EBADF); 640 } 641 642 self.get_file_by_fd(fd).ok_or(SystemError::EBADF)?; 643 644 // 把文件描述符数组对应位置设置为空 645 let file = self.fds[fd as usize].take().unwrap(); 646 647 assert!(Arc::strong_count(&file) == 1); 648 return Ok(()); 649 } 650 651 #[allow(dead_code)] 652 pub fn iter(&self) -> FileDescriptorIterator { 653 return FileDescriptorIterator::new(self); 654 } 655 656 pub fn close_on_exec(&mut self) { 657 for i in 0..FileDescriptorVec::PROCESS_MAX_FD { 658 if let Some(file) = &self.fds[i] { 659 let to_drop = file.close_on_exec(); 660 if to_drop { 661 if let Err(r) = self.drop_fd(i as i32) { 662 kerror!( 663 "Failed to close file: pid = {:?}, fd = {}, error = {:?}", 664 ProcessManager::current_pcb().pid(), 665 i, 666 r 667 ); 668 } 669 } 670 } 671 } 672 } 673 } 674 675 #[derive(Debug)] 676 pub struct FileDescriptorIterator<'a> { 677 fds: &'a FileDescriptorVec, 678 index: usize, 679 } 680 681 impl<'a> FileDescriptorIterator<'a> { 682 pub fn new(fds: &'a FileDescriptorVec) -> Self { 683 return Self { fds, index: 0 }; 684 } 685 } 686 687 impl<'a> Iterator for FileDescriptorIterator<'a> { 688 type Item = (i32, Arc<File>); 689 690 fn next(&mut self) -> Option<Self::Item> { 691 while self.index < FileDescriptorVec::PROCESS_MAX_FD { 692 let fd = self.index as i32; 693 self.index += 1; 694 if let Some(file) = self.fds.get_file_by_fd(fd) { 695 return Some((fd, file)); 696 } 697 } 698 return None; 699 } 700 } 701