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 { 45 fn default() -> Self { 46 return Self::Unused; 47 } 48 } 49 50 impl FilePrivateData { 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] 114 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 文件的打开模式 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) 错误码 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) 错误码 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)`: 成功读取的字节数 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)`: 成功写入的字节数 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 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 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 获取文件的元数据 270 pub fn metadata(&self) -> Result<Metadata, SystemError> { 271 return self.inode.metadata(); 272 } 273 274 /// @brief 根据inode号获取子目录项的名字 275 #[allow(dead_code)] 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 调整的起始位置 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] 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] 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结构体的大小 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 394 pub fn inode(&self) -> Arc<dyn IndexNode> { 395 return self.inode.clone(); 396 } 397 398 /// @brief 尝试克隆一个文件 399 /// 400 /// @return Option<File> 克隆后的文件结构体。如果克隆失败，返回None 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] 420 pub fn file_type(&self) -> FileType { 421 return self.file_type; 422 } 423 424 /// @brief 获取文件的打开模式 425 #[inline] 426 pub fn mode(&self) -> FileMode { 427 return self.mode; 428 } 429 430 /// 获取文件是否在execve时关闭 431 #[inline] 432 pub fn close_on_exec(&self) -> bool { 433 return self.mode.contains(FileMode::O_CLOEXEC); 434 } 435 436 /// 设置文件是否在execve时关闭 437 #[inline] 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 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(错误码) 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通知 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 _ => return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP), 488 } 489 } 490 491 /// ## 删除一个绑定的epoll 492 pub fn remove_epoll(&mut self, epoll: &Weak<SpinLock<EventPoll>>) -> Result<(), SystemError> { 493 match self.file_type { 494 FileType::Socket => { 495 let inode = self.inode.downcast_ref::<SocketInode>().unwrap(); 496 let mut socket = inode.inner(); 497 498 return socket.remove_epoll(epoll); 499 } 500 _ => return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP), 501 } 502 } 503 504 pub fn poll(&self) -> Result<usize, SystemError> { 505 self.inode.poll(&self.private_data) 506 } 507 } 508 509 impl Drop for File { 510 fn drop(&mut self) { 511 let r: Result<(), SystemError> = self.inode.close(&mut self.private_data); 512 // 打印错误信息 513 if r.is_err() { 514 kerror!( 515 "pid: {:?} failed to close file: {:?}, errno={:?}", 516 ProcessManager::current_pcb().pid(), 517 self, 518 r.as_ref().unwrap_err() 519 ); 520 } 521 } 522 } 523 524 /// @brief pcb里面的文件描述符数组 525 #[derive(Debug)] 526 pub struct FileDescriptorVec { 527 /// 当前进程打开的文件描述符 528 fds: Vec<Option<Arc<SpinLock<File>>>>, 529 } 530 531 impl FileDescriptorVec { 532 pub const PROCESS_MAX_FD: usize = 1024; 533 534 #[inline(never)] 535 pub fn new() -> FileDescriptorVec { 536 let mut data = Vec::with_capacity(FileDescriptorVec::PROCESS_MAX_FD); 537 data.resize(FileDescriptorVec::PROCESS_MAX_FD, None); 538 539 // 初始化文件描述符数组结构体 540 return FileDescriptorVec { fds: data }; 541 } 542 543 /// @brief 克隆一个文件描述符数组 544 /// 545 /// @return FileDescriptorVec 克隆后的文件描述符数组 546 pub fn clone(&self) -> FileDescriptorVec { 547 let mut res = FileDescriptorVec::new(); 548 for i in 0..FileDescriptorVec::PROCESS_MAX_FD { 549 if let Some(file) = &self.fds[i] { 550 if let Some(file) = file.lock().try_clone() { 551 res.fds[i] = Some(Arc::new(SpinLock::new(file))); 552 } 553 } 554 } 555 return res; 556 } 557 558 /// @brief 判断文件描述符序号是否合法 559 /// 560 /// @return true 合法 561 /// 562 /// @return false 不合法 563 #[inline] 564 pub fn validate_fd(fd: i32) -> bool { 565 if fd < 0 || fd as usize > FileDescriptorVec::PROCESS_MAX_FD { 566 return false; 567 } else { 568 return true; 569 } 570 } 571 572 /// 申请文件描述符，并把文件对象存入其中。 573 /// 574 /// ## 参数 575 /// 576 /// - `file` 要存放的文件对象 577 /// - `fd` 如果为Some(i32)，表示指定要申请这个文件描述符，如果这个文件描述符已经被使用，那么返回EBADF 578 /// 579 /// ## 返回值 580 /// 581 /// - `Ok(i32)` 申请成功，返回申请到的文件描述符 582 /// - `Err(SystemError)` 申请失败，返回错误码，并且，file对象将被drop掉 583 pub fn alloc_fd(&mut self, file: File, fd: Option<i32>) -> Result<i32, SystemError> { 584 if fd.is_some() { 585 // 指定了要申请的文件描述符编号 586 let new_fd = fd.unwrap(); 587 let x = &mut self.fds[new_fd as usize]; 588 if x.is_none() { 589 *x = Some(Arc::new(SpinLock::new(file))); 590 return Ok(new_fd); 591 } else { 592 return Err(SystemError::EBADF); 593 } 594 } else { 595 // 没有指定要申请的文件描述符编号 596 for i in 0..FileDescriptorVec::PROCESS_MAX_FD { 597 if self.fds[i].is_none() { 598 self.fds[i] = Some(Arc::new(SpinLock::new(file))); 599 return Ok(i as i32); 600 } 601 } 602 return Err(SystemError::EMFILE); 603 } 604 } 605 606 /// 根据文件描述符序号，获取文件结构体的Arc指针 607 /// 608 /// ## 参数 609 /// 610 /// - `fd` 文件描述符序号 611 pub fn get_file_by_fd(&self, fd: i32) -> Option<Arc<SpinLock<File>>> { 612 if !FileDescriptorVec::validate_fd(fd) { 613 return None; 614 } 615 return self.fds[fd as usize].clone(); 616 } 617 618 /// 释放文件描述符，同时关闭文件。 619 /// 620 /// ## 参数 621 /// 622 /// - `fd` 文件描述符序号 623 pub fn drop_fd(&mut self, fd: i32) -> Result<(), SystemError> { 624 // 判断文件描述符的数字是否超过限制 625 if !FileDescriptorVec::validate_fd(fd) { 626 return Err(SystemError::EBADF); 627 } 628 629 self.get_file_by_fd(fd).ok_or(SystemError::EBADF)?; 630 631 // 把文件描述符数组对应位置设置为空 632 let file = self.fds[fd as usize].take().unwrap(); 633 634 assert!(Arc::strong_count(&file) == 1); 635 return Ok(()); 636 } 637 638 #[allow(dead_code)] 639 pub fn iter(&self) -> FileDescriptorIterator { 640 return FileDescriptorIterator::new(self); 641 } 642 643 pub fn close_on_exec(&mut self) { 644 for i in 0..FileDescriptorVec::PROCESS_MAX_FD { 645 if let Some(file) = &self.fds[i] { 646 let to_drop = file.lock().close_on_exec(); 647 if to_drop { 648 if let Err(r) = self.drop_fd(i as i32) { 649 kerror!( 650 "Failed to close file: pid = {:?}, fd = {}, error = {:?}", 651 ProcessManager::current_pcb().pid(), 652 i, 653 r 654 ); 655 } 656 } 657 } 658 } 659 } 660 } 661 662 #[derive(Debug)] 663 pub struct FileDescriptorIterator<'a> { 664 fds: &'a FileDescriptorVec, 665 index: usize, 666 } 667 668 impl<'a> FileDescriptorIterator<'a> { 669 pub fn new(fds: &'a FileDescriptorVec) -> Self { 670 return Self { fds, index: 0 }; 671 } 672 } 673 674 impl<'a> Iterator for FileDescriptorIterator<'a> { 675 type Item = (i32, Arc<SpinLock<File>>); 676 677 fn next(&mut self) -> Option<Self::Item> { 678 while self.index < FileDescriptorVec::PROCESS_MAX_FD { 679 let fd = self.index as i32; 680 self.index += 1; 681 if let Some(file) = self.fds.get_file_by_fd(fd) { 682 return Some((fd, file)); 683 } 684 } 685 return None; 686 } 687 } 688