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