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