140609970SGnoCiYeH use alloc::{ 240609970SGnoCiYeH string::String, 340609970SGnoCiYeH sync::{Arc, Weak}, 440609970SGnoCiYeH vec::Vec, 540609970SGnoCiYeH }; 691e9d4abSLoGin use system_error::SystemError; 7004e86ffSlogin 8004e86ffSlogin use crate::{ 9b087521eSChiichen driver::{ 10b087521eSChiichen base::{block::SeekFrom, device::DevicePrivateData}, 11b087521eSChiichen tty::TtyFilePrivateData, 12b087521eSChiichen }, 13b087521eSChiichen filesystem::procfs::ProcfsFilePrivateData, 145e948c56SGnoCiYeH ipc::pipe::{LockedPipeInode, PipeFsPrivateData}, 15b087521eSChiichen kerror, 161496ba7bSLoGin libs::spinlock::SpinLock, 1740609970SGnoCiYeH net::{ 1840609970SGnoCiYeH event_poll::{EPollItem, EPollPrivateData, EventPoll}, 1940609970SGnoCiYeH socket::SocketInode, 2040609970SGnoCiYeH }, 211496ba7bSLoGin process::ProcessManager, 22004e86ffSlogin }; 23004e86ffSlogin 242dbef785SGnoCiYeH use super::{Dirent, FileType, IndexNode, InodeId, Metadata, SpecialNodeData}; 25004e86ffSlogin 26004e86ffSlogin /// 文件私有信息的枚举类型 27004e86ffSlogin #[derive(Debug, Clone)] 28bf4a4899SLoGin #[allow(dead_code)] 29004e86ffSlogin pub enum FilePrivateData { 30876cb89eSGnoCiYeH /// 管道文件私有信息 31876cb89eSGnoCiYeH Pipefs(PipeFsPrivateData), 320d48c3c9Slogin /// procfs文件私有信息 33004e86ffSlogin Procfs(ProcfsFilePrivateData), 34b087521eSChiichen /// 设备文件的私有信息 35b087521eSChiichen DevFS(DevicePrivateData), 36b087521eSChiichen /// tty设备文件的私有信息 370d48c3c9Slogin Tty(TtyFilePrivateData), 3840609970SGnoCiYeH /// epoll私有信息 3940609970SGnoCiYeH EPoll(EPollPrivateData), 400d48c3c9Slogin /// 不需要文件私有信息 41004e86ffSlogin Unused, 42004e86ffSlogin } 43004e86ffSlogin 44004e86ffSlogin impl Default for FilePrivateData { 45004e86ffSlogin fn default() -> Self { 46004e86ffSlogin return Self::Unused; 47004e86ffSlogin } 48004e86ffSlogin } 49004e86ffSlogin 505e948c56SGnoCiYeH impl FilePrivateData { 515e948c56SGnoCiYeH pub fn update_mode(&mut self, mode: FileMode) { 525e948c56SGnoCiYeH if let FilePrivateData::Pipefs(pdata) = self { 535e948c56SGnoCiYeH pdata.set_mode(mode); 545e948c56SGnoCiYeH } 555e948c56SGnoCiYeH } 565e948c56SGnoCiYeH } 575e948c56SGnoCiYeH 58004e86ffSlogin bitflags! { 59004e86ffSlogin /// @brief 文件打开模式 60004e86ffSlogin /// 其中,低2bit组合而成的数字的值,用于表示访问权限。其他的bit,才支持通过按位或的方式来表示参数 61004e86ffSlogin /// 62004e86ffSlogin /// 与Linux 5.19.10的uapi/asm-generic/fcntl.h相同 63e7071df6SLoGin /// https://code.dragonos.org.cn/xref/linux-5.19.10/tools/include/uapi/asm-generic/fcntl.h#19 64004e86ffSlogin pub struct FileMode: u32{ 65004e86ffSlogin /* File access modes for `open' and `fcntl'. */ 66004e86ffSlogin /// Open Read-only 6784407d36Slogin const O_RDONLY = 0o0; 68004e86ffSlogin /// Open Write-only 6984407d36Slogin const O_WRONLY = 0o1; 70004e86ffSlogin /// Open read/write 7184407d36Slogin const O_RDWR = 0o2; 72004e86ffSlogin /// Mask for file access modes 7384407d36Slogin const O_ACCMODE = 0o00000003; 74004e86ffSlogin 75004e86ffSlogin /* Bits OR'd into the second argument to open. */ 76004e86ffSlogin /// Create file if it does not exist 7784407d36Slogin const O_CREAT = 0o00000100; 78004e86ffSlogin /// Fail if file already exists 7984407d36Slogin const O_EXCL = 0o00000200; 80004e86ffSlogin /// Do not assign controlling terminal 8184407d36Slogin const O_NOCTTY = 0o00000400; 82004e86ffSlogin /// 文件存在且是普通文件,并以O_RDWR或O_WRONLY打开,则它会被清空 8384407d36Slogin const O_TRUNC = 0o00001000; 84004e86ffSlogin /// 文件指针会被移动到文件末尾 8584407d36Slogin const O_APPEND = 0o00002000; 86004e86ffSlogin /// 非阻塞式IO模式 8784407d36Slogin const O_NONBLOCK = 0o00004000; 8820e3152eSlogin /// 每次write都等待物理I/O完成,但是如果写操作不影响读取刚写入的数据,则不等待文件属性更新 8984407d36Slogin const O_DSYNC = 0o00010000; 90004e86ffSlogin /// fcntl, for BSD compatibility 9184407d36Slogin const FASYNC = 0o00020000; 92004e86ffSlogin /* direct disk access hint */ 9384407d36Slogin const O_DIRECT = 0o00040000; 9484407d36Slogin const O_LARGEFILE = 0o00100000; 95004e86ffSlogin /// 打开的必须是一个目录 9684407d36Slogin const O_DIRECTORY = 0o00200000; 97004e86ffSlogin /// Do not follow symbolic links 9884407d36Slogin const O_NOFOLLOW = 0o00400000; 9984407d36Slogin const O_NOATIME = 0o01000000; 100004e86ffSlogin /// set close_on_exec 10184407d36Slogin const O_CLOEXEC = 0o02000000; 10220e3152eSlogin /// 每次write都等到物理I/O完成,包括write引起的文件属性的更新 10320e3152eSlogin const O_SYNC = 0o04000000; 1040fb515b0SLoGin 1050fb515b0SLoGin const O_PATH = 0o10000000; 1060fb515b0SLoGin 1070fb515b0SLoGin const O_PATH_FLAGS = Self::O_DIRECTORY.bits|Self::O_NOFOLLOW.bits|Self::O_CLOEXEC.bits|Self::O_PATH.bits; 108004e86ffSlogin } 109004e86ffSlogin } 110004e86ffSlogin 11120e3152eSlogin impl FileMode { 11220e3152eSlogin /// @brief 获取文件的访问模式的值 11320e3152eSlogin #[inline] 11420e3152eSlogin pub fn accmode(&self) -> u32 { 11520e3152eSlogin return self.bits() & FileMode::O_ACCMODE.bits(); 11620e3152eSlogin } 11720e3152eSlogin } 118004e86ffSlogin /// @brief 抽象文件结构体 11964aea4b3SGou Ngai #[derive(Debug)] 120004e86ffSlogin pub struct File { 121004e86ffSlogin inode: Arc<dyn IndexNode>, 122004e86ffSlogin /// 对于文件,表示字节偏移量;对于文件夹,表示当前操作的子目录项偏移量 123004e86ffSlogin offset: usize, 124004e86ffSlogin /// 文件的打开模式 125004e86ffSlogin mode: FileMode, 126004e86ffSlogin /// 文件类型 127004e86ffSlogin file_type: FileType, 128004e86ffSlogin /// readdir时候用的,暂存的本次循环中,所有子目录项的名字的数组 129004e86ffSlogin readdir_subdirs_name: Vec<String>, 130004e86ffSlogin pub private_data: FilePrivateData, 131004e86ffSlogin } 132004e86ffSlogin 133004e86ffSlogin impl File { 134004e86ffSlogin /// @brief 创建一个新的文件对象 135004e86ffSlogin /// 136004e86ffSlogin /// @param inode 文件对象对应的inode 137004e86ffSlogin /// @param mode 文件的打开模式 138676b8ef6SMork pub fn new(inode: Arc<dyn IndexNode>, mode: FileMode) -> Result<Self, SystemError> { 1392dbef785SGnoCiYeH let mut inode = inode; 1402dbef785SGnoCiYeH let file_type = inode.metadata()?.file_type; 1412dbef785SGnoCiYeH match file_type { 1422dbef785SGnoCiYeH FileType::Pipe => { 1432dbef785SGnoCiYeH if let Some(SpecialNodeData::Pipe(pipe_inode)) = inode.special_node() { 1442dbef785SGnoCiYeH inode = pipe_inode; 1452dbef785SGnoCiYeH } 1462dbef785SGnoCiYeH } 1472dbef785SGnoCiYeH _ => {} 1482dbef785SGnoCiYeH } 1492dbef785SGnoCiYeH 150004e86ffSlogin let mut f = File { 151004e86ffSlogin inode, 152004e86ffSlogin offset: 0, 153004e86ffSlogin mode, 154004e86ffSlogin file_type, 155004e86ffSlogin readdir_subdirs_name: Vec::new(), 156004e86ffSlogin private_data: FilePrivateData::default(), 157004e86ffSlogin }; 158004e86ffSlogin // kdebug!("inode:{:?}",f.inode); 1590d48c3c9Slogin f.inode.open(&mut f.private_data, &mode)?; 16040314b30SXiaoye Zheng 161004e86ffSlogin return Ok(f); 162004e86ffSlogin } 163004e86ffSlogin 164004e86ffSlogin /// @brief 从文件中读取指定的字节数到buffer中 165004e86ffSlogin /// 166004e86ffSlogin /// @param len 要读取的字节数 167004e86ffSlogin /// @param buf 目标buffer 168004e86ffSlogin /// 169004e86ffSlogin /// @return Ok(usize) 成功读取的字节数 170676b8ef6SMork /// @return Err(SystemError) 错误码 171676b8ef6SMork pub fn read(&mut self, len: usize, buf: &mut [u8]) -> Result<usize, SystemError> { 172*27b967a3S裕依 self.do_read(self.offset, len, buf, true) 173004e86ffSlogin } 174004e86ffSlogin 175004e86ffSlogin /// @brief 从buffer向文件写入指定的字节数的数据 176004e86ffSlogin /// 177004e86ffSlogin /// @param len 要写入的字节数 178004e86ffSlogin /// @param buf 源数据buffer 179004e86ffSlogin /// 180004e86ffSlogin /// @return Ok(usize) 成功写入的字节数 181676b8ef6SMork /// @return Err(SystemError) 错误码 182676b8ef6SMork pub fn write(&mut self, len: usize, buf: &[u8]) -> Result<usize, SystemError> { 183*27b967a3S裕依 self.do_write(self.offset, len, buf, true) 184*27b967a3S裕依 } 185*27b967a3S裕依 186*27b967a3S裕依 /// ## 从文件中指定的偏移处读取指定的字节数到buf中 187*27b967a3S裕依 /// 188*27b967a3S裕依 /// ### 参数 189*27b967a3S裕依 /// - `offset`: 文件偏移量 190*27b967a3S裕依 /// - `len`: 要读取的字节数 191*27b967a3S裕依 /// - `buf`: 读出缓冲区 192*27b967a3S裕依 /// 193*27b967a3S裕依 /// ### 返回值 194*27b967a3S裕依 /// - `Ok(usize)`: 成功读取的字节数 195*27b967a3S裕依 pub fn pread( 196*27b967a3S裕依 &mut self, 197*27b967a3S裕依 offset: usize, 198*27b967a3S裕依 len: usize, 199*27b967a3S裕依 buf: &mut [u8], 200*27b967a3S裕依 ) -> Result<usize, SystemError> { 201*27b967a3S裕依 self.do_read(offset, len, buf, false) 202*27b967a3S裕依 } 203*27b967a3S裕依 204*27b967a3S裕依 /// ## 从buf向文件中指定的偏移处写入指定的字节数的数据 205*27b967a3S裕依 /// 206*27b967a3S裕依 /// ### 参数 207*27b967a3S裕依 /// - `offset`: 文件偏移量 208*27b967a3S裕依 /// - `len`: 要写入的字节数 209*27b967a3S裕依 /// - `buf`: 写入缓冲区 210*27b967a3S裕依 /// 211*27b967a3S裕依 /// ### 返回值 212*27b967a3S裕依 /// - `Ok(usize)`: 成功写入的字节数 213*27b967a3S裕依 pub fn pwrite(&mut self, offset: usize, len: usize, buf: &[u8]) -> Result<usize, SystemError> { 214*27b967a3S裕依 self.do_write(offset, len, buf, false) 215*27b967a3S裕依 } 216*27b967a3S裕依 217*27b967a3S裕依 fn do_read( 218*27b967a3S裕依 &mut self, 219*27b967a3S裕依 offset: usize, 220*27b967a3S裕依 len: usize, 221*27b967a3S裕依 buf: &mut [u8], 222*27b967a3S裕依 update_offset: bool, 223*27b967a3S裕依 ) -> Result<usize, SystemError> { 224*27b967a3S裕依 // 先检查本文件在权限等规则下,是否可读取。 225*27b967a3S裕依 self.readable()?; 226*27b967a3S裕依 if buf.len() < len { 227*27b967a3S裕依 return Err(SystemError::ENOBUFS); 228*27b967a3S裕依 } 229*27b967a3S裕依 230*27b967a3S裕依 let len = self 231*27b967a3S裕依 .inode 232*27b967a3S裕依 .read_at(offset, len, buf, &mut self.private_data)?; 233*27b967a3S裕依 234*27b967a3S裕依 if update_offset { 235*27b967a3S裕依 self.offset += len; 236*27b967a3S裕依 } 237*27b967a3S裕依 238*27b967a3S裕依 Ok(len) 239*27b967a3S裕依 } 240*27b967a3S裕依 241*27b967a3S裕依 fn do_write( 242*27b967a3S裕依 &mut self, 243*27b967a3S裕依 offset: usize, 244*27b967a3S裕依 len: usize, 245*27b967a3S裕依 buf: &[u8], 246*27b967a3S裕依 update_offset: bool, 247*27b967a3S裕依 ) -> Result<usize, SystemError> { 248004e86ffSlogin // 先检查本文件在权限等规则下,是否可写入。 249004e86ffSlogin self.writeable()?; 250004e86ffSlogin if buf.len() < len { 251676b8ef6SMork return Err(SystemError::ENOBUFS); 252004e86ffSlogin } 2536d81180bSLoGin 2546d81180bSLoGin // 如果文件指针已经超过了文件大小,则需要扩展文件大小 255*27b967a3S裕依 if offset > self.inode.metadata()?.size as usize { 256*27b967a3S裕依 self.inode.resize(offset)?; 2576d81180bSLoGin } 258004e86ffSlogin let len = self 259004e86ffSlogin .inode 260*27b967a3S裕依 .write_at(offset, len, buf, &mut self.private_data)?; 261*27b967a3S裕依 262*27b967a3S裕依 if update_offset { 263004e86ffSlogin self.offset += len; 264*27b967a3S裕依 } 265*27b967a3S裕依 266*27b967a3S裕依 Ok(len) 267004e86ffSlogin } 268004e86ffSlogin 269004e86ffSlogin /// @brief 获取文件的元数据 270676b8ef6SMork pub fn metadata(&self) -> Result<Metadata, SystemError> { 271004e86ffSlogin return self.inode.metadata(); 272004e86ffSlogin } 273004e86ffSlogin 274004e86ffSlogin /// @brief 根据inode号获取子目录项的名字 275bf4a4899SLoGin #[allow(dead_code)] 2766b4e7a29SLoGin pub fn get_entry_name(&self, ino: InodeId) -> Result<String, SystemError> { 277004e86ffSlogin return self.inode.get_entry_name(ino); 278004e86ffSlogin } 279004e86ffSlogin 280004e86ffSlogin /// @brief 调整文件操作指针的位置 281004e86ffSlogin /// 282004e86ffSlogin /// @param origin 调整的起始位置 283676b8ef6SMork pub fn lseek(&mut self, origin: SeekFrom) -> Result<usize, SystemError> { 28440fe15e0SLoGin let file_type = self.inode.metadata()?.file_type; 285bfafc102Slogin match file_type { 286bfafc102Slogin FileType::Pipe | FileType::CharDevice => { 287676b8ef6SMork return Err(SystemError::ESPIPE); 288004e86ffSlogin } 289bfafc102Slogin _ => {} 290bfafc102Slogin } 291bfafc102Slogin 292004e86ffSlogin let pos: i64; 293004e86ffSlogin match origin { 294004e86ffSlogin SeekFrom::SeekSet(offset) => { 295004e86ffSlogin pos = offset; 296004e86ffSlogin } 297004e86ffSlogin SeekFrom::SeekCurrent(offset) => { 298004e86ffSlogin pos = self.offset as i64 + offset; 299004e86ffSlogin } 300004e86ffSlogin SeekFrom::SeekEnd(offset) => { 301004e86ffSlogin let metadata = self.metadata()?; 302004e86ffSlogin pos = metadata.size + offset; 303004e86ffSlogin } 304004e86ffSlogin SeekFrom::Invalid => { 305676b8ef6SMork return Err(SystemError::EINVAL); 306004e86ffSlogin } 307004e86ffSlogin } 3086d81180bSLoGin // 根据linux man page, lseek允许超出文件末尾,并且不改变文件大小 3096d81180bSLoGin // 当pos超出文件末尾时,read返回0。直到开始写入数据时,才会改变文件大小 3106d81180bSLoGin if pos < 0 { 311676b8ef6SMork return Err(SystemError::EOVERFLOW); 312004e86ffSlogin } 313004e86ffSlogin self.offset = pos as usize; 314004e86ffSlogin return Ok(self.offset); 315004e86ffSlogin } 316004e86ffSlogin 317004e86ffSlogin /// @brief 判断当前文件是否可读 318004e86ffSlogin #[inline] 319676b8ef6SMork pub fn readable(&self) -> Result<(), SystemError> { 320004e86ffSlogin // 暂时认为只要不是write only, 就可读 321004e86ffSlogin if self.mode == FileMode::O_WRONLY { 322676b8ef6SMork return Err(SystemError::EPERM); 323004e86ffSlogin } 324004e86ffSlogin 325004e86ffSlogin return Ok(()); 326004e86ffSlogin } 327004e86ffSlogin 328004e86ffSlogin /// @brief 判断当前文件是否可写 329004e86ffSlogin #[inline] 330676b8ef6SMork pub fn writeable(&self) -> Result<(), SystemError> { 331004e86ffSlogin // 暂时认为只要不是read only, 就可写 332004e86ffSlogin if self.mode == FileMode::O_RDONLY { 333676b8ef6SMork return Err(SystemError::EPERM); 334004e86ffSlogin } 335004e86ffSlogin 336004e86ffSlogin return Ok(()); 337004e86ffSlogin } 338004e86ffSlogin 339004e86ffSlogin /// @biref 充填dirent结构体 340004e86ffSlogin /// @return 返回dirent结构体的大小 341676b8ef6SMork pub fn readdir(&mut self, dirent: &mut Dirent) -> Result<u64, SystemError> { 342004e86ffSlogin let inode: &Arc<dyn IndexNode> = &self.inode; 343004e86ffSlogin 344004e86ffSlogin // 如果偏移量为0 345004e86ffSlogin if self.offset == 0 { 3461effcfe5SGnoCiYeH // 通过list更新readdir_subdirs_name 347004e86ffSlogin self.readdir_subdirs_name = inode.list()?; 348004e86ffSlogin self.readdir_subdirs_name.sort(); 349004e86ffSlogin } 350004e86ffSlogin // kdebug!("sub_entries={sub_entries:?}"); 3511effcfe5SGnoCiYeH 3521effcfe5SGnoCiYeH // 已经读到末尾 3531effcfe5SGnoCiYeH if self.offset == self.readdir_subdirs_name.len() { 354004e86ffSlogin self.offset = 0; 355004e86ffSlogin return Ok(0); 356004e86ffSlogin } 3571effcfe5SGnoCiYeH let name = &self.readdir_subdirs_name[self.offset]; 358004e86ffSlogin let sub_inode: Arc<dyn IndexNode> = match inode.find(&name) { 359004e86ffSlogin Ok(i) => i, 360004e86ffSlogin Err(e) => { 36106d5e247SLoGin kerror!( 36206d5e247SLoGin "Readdir error: Failed to find sub inode:{name:?}, file={self:?}, error={e:?}" 36306d5e247SLoGin ); 364004e86ffSlogin return Err(e); 365004e86ffSlogin } 366004e86ffSlogin }; 367004e86ffSlogin 368004e86ffSlogin let name_bytes: &[u8] = name.as_bytes(); 369004e86ffSlogin 370004e86ffSlogin // 根据posix的规定,dirent中的d_name是一个不定长的数组,因此需要unsafe来拷贝数据 371004e86ffSlogin unsafe { 372004e86ffSlogin let ptr = &mut dirent.d_name as *mut u8; 3731effcfe5SGnoCiYeH 374004e86ffSlogin let buf: &mut [u8] = 3751effcfe5SGnoCiYeH ::core::slice::from_raw_parts_mut::<'static, u8>(ptr, name_bytes.len() + 1); 3761effcfe5SGnoCiYeH buf[0..name_bytes.len()].copy_from_slice(name_bytes); 3771effcfe5SGnoCiYeH buf[name_bytes.len()] = 0; 378004e86ffSlogin } 379004e86ffSlogin 3801effcfe5SGnoCiYeH self.offset += 1; 3811effcfe5SGnoCiYeH dirent.d_ino = sub_inode.metadata().unwrap().inode_id.into() as u64; 3821effcfe5SGnoCiYeH dirent.d_type = sub_inode.metadata().unwrap().file_type.get_file_type_num() as u8; 3831effcfe5SGnoCiYeH 384004e86ffSlogin // 计算dirent结构体的大小 385bb0e4d41SGnoCiYeH let size = (name_bytes.len() + ::core::mem::size_of::<Dirent>() 386bb0e4d41SGnoCiYeH - ::core::mem::size_of_val(&dirent.d_name)) as u64; 387bb0e4d41SGnoCiYeH 388bb0e4d41SGnoCiYeH dirent.d_reclen = size as u16; 389bb0e4d41SGnoCiYeH dirent.d_off += dirent.d_reclen as i64; 390bb0e4d41SGnoCiYeH 391bb0e4d41SGnoCiYeH return Ok(size); 392004e86ffSlogin } 39364aea4b3SGou Ngai 394004e86ffSlogin pub fn inode(&self) -> Arc<dyn IndexNode> { 395004e86ffSlogin return self.inode.clone(); 396004e86ffSlogin } 39764aea4b3SGou Ngai 39864aea4b3SGou Ngai /// @brief 尝试克隆一个文件 39964aea4b3SGou Ngai /// 4001496ba7bSLoGin /// @return Option<File> 克隆后的文件结构体。如果克隆失败,返回None 4011496ba7bSLoGin pub fn try_clone(&self) -> Option<File> { 4021496ba7bSLoGin let mut res = Self { 40364aea4b3SGou Ngai inode: self.inode.clone(), 40464aea4b3SGou Ngai offset: self.offset.clone(), 40564aea4b3SGou Ngai mode: self.mode.clone(), 40664aea4b3SGou Ngai file_type: self.file_type.clone(), 40764aea4b3SGou Ngai readdir_subdirs_name: self.readdir_subdirs_name.clone(), 40864aea4b3SGou Ngai private_data: self.private_data.clone(), 4091496ba7bSLoGin }; 41064aea4b3SGou Ngai // 调用inode的open方法,让inode知道有新的文件打开了这个inode 41164aea4b3SGou Ngai if self.inode.open(&mut res.private_data, &res.mode).is_err() { 41264aea4b3SGou Ngai return None; 41364aea4b3SGou Ngai } 41464aea4b3SGou Ngai 41564aea4b3SGou Ngai return Some(res); 41664aea4b3SGou Ngai } 417cde5492fSlogin 418cde5492fSlogin /// @brief 获取文件的类型 419cde5492fSlogin #[inline] 420cde5492fSlogin pub fn file_type(&self) -> FileType { 421cde5492fSlogin return self.file_type; 422cde5492fSlogin } 4236d81180bSLoGin 4246d81180bSLoGin /// @brief 获取文件的打开模式 4256d81180bSLoGin #[inline] 4266d81180bSLoGin pub fn mode(&self) -> FileMode { 4276d81180bSLoGin return self.mode; 4286d81180bSLoGin } 4296d81180bSLoGin 4306d81180bSLoGin /// 获取文件是否在execve时关闭 4316d81180bSLoGin #[inline] 4326d81180bSLoGin pub fn close_on_exec(&self) -> bool { 4336d81180bSLoGin return self.mode.contains(FileMode::O_CLOEXEC); 4346d81180bSLoGin } 4356d81180bSLoGin 4366d81180bSLoGin /// 设置文件是否在execve时关闭 4376d81180bSLoGin #[inline] 4386d81180bSLoGin pub fn set_close_on_exec(&mut self, close_on_exec: bool) { 4396d81180bSLoGin if close_on_exec { 4406d81180bSLoGin self.mode.insert(FileMode::O_CLOEXEC); 4416d81180bSLoGin } else { 4426d81180bSLoGin self.mode.remove(FileMode::O_CLOEXEC); 4436d81180bSLoGin } 4446d81180bSLoGin } 4456d81180bSLoGin 4466d81180bSLoGin pub fn set_mode(&mut self, mode: FileMode) -> Result<(), SystemError> { 4476d81180bSLoGin // todo: 是否需要调用inode的open方法,以更新private data(假如它与mode有关的话)? 4486d81180bSLoGin // 也许需要加个更好的设计,让inode知晓文件的打开模式发生了变化,让它自己决定是否需要更新private data 4496d81180bSLoGin 4506d81180bSLoGin // 直接修改文件的打开模式 4516d81180bSLoGin self.mode = mode; 4525e948c56SGnoCiYeH self.private_data.update_mode(mode); 4536d81180bSLoGin return Ok(()); 4546d81180bSLoGin } 4556d81180bSLoGin 4566d81180bSLoGin /// @brief 重新设置文件的大小 4576d81180bSLoGin /// 4586d81180bSLoGin /// 如果文件大小增加,则文件内容不变,但是文件的空洞部分会被填充为0 4596d81180bSLoGin /// 如果文件大小减小,则文件内容会被截断 4606d81180bSLoGin /// 4616d81180bSLoGin /// @return 成功:Ok() 4626d81180bSLoGin /// 失败:Err(错误码) 4631496ba7bSLoGin pub fn ftruncate(&self, len: usize) -> Result<(), SystemError> { 4646d81180bSLoGin // 如果文件不可写,返回错误 4656d81180bSLoGin self.writeable()?; 4666d81180bSLoGin 4676d81180bSLoGin // 调用inode的truncate方法 4686d81180bSLoGin self.inode.resize(len)?; 4696d81180bSLoGin return Ok(()); 4706d81180bSLoGin } 47140609970SGnoCiYeH 47240609970SGnoCiYeH /// ## 向该文件添加一个EPollItem对象 47340609970SGnoCiYeH /// 47440609970SGnoCiYeH /// 在文件状态发生变化时,需要向epoll通知 47540609970SGnoCiYeH pub fn add_epoll(&mut self, epitem: Arc<EPollItem>) -> Result<(), SystemError> { 47640609970SGnoCiYeH match self.file_type { 47740609970SGnoCiYeH FileType::Socket => { 47840609970SGnoCiYeH let inode = self.inode.downcast_ref::<SocketInode>().unwrap(); 47940609970SGnoCiYeH let mut socket = inode.inner(); 48040609970SGnoCiYeH 48140609970SGnoCiYeH return socket.add_epoll(epitem); 48240609970SGnoCiYeH } 4835e948c56SGnoCiYeH FileType::Pipe => { 4845e948c56SGnoCiYeH let inode = self.inode.downcast_ref::<LockedPipeInode>().unwrap(); 4855e948c56SGnoCiYeH return inode.inner().lock().add_epoll(epitem); 4865e948c56SGnoCiYeH } 48740609970SGnoCiYeH _ => return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP), 48840609970SGnoCiYeH } 48940609970SGnoCiYeH } 49040609970SGnoCiYeH 49140609970SGnoCiYeH /// ## 删除一个绑定的epoll 49240609970SGnoCiYeH pub fn remove_epoll(&mut self, epoll: &Weak<SpinLock<EventPoll>>) -> Result<(), SystemError> { 49340609970SGnoCiYeH match self.file_type { 49440609970SGnoCiYeH FileType::Socket => { 49540609970SGnoCiYeH let inode = self.inode.downcast_ref::<SocketInode>().unwrap(); 49640609970SGnoCiYeH let mut socket = inode.inner(); 49740609970SGnoCiYeH 49840609970SGnoCiYeH return socket.remove_epoll(epoll); 49940609970SGnoCiYeH } 50040609970SGnoCiYeH _ => return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP), 50140609970SGnoCiYeH } 50240609970SGnoCiYeH } 50340609970SGnoCiYeH 50440609970SGnoCiYeH pub fn poll(&self) -> Result<usize, SystemError> { 5055e948c56SGnoCiYeH self.inode.poll(&self.private_data) 50640609970SGnoCiYeH } 507004e86ffSlogin } 508004e86ffSlogin 509004e86ffSlogin impl Drop for File { 510004e86ffSlogin fn drop(&mut self) { 511676b8ef6SMork let r: Result<(), SystemError> = self.inode.close(&mut self.private_data); 512004e86ffSlogin // 打印错误信息 513004e86ffSlogin if r.is_err() { 514004e86ffSlogin kerror!( 5151496ba7bSLoGin "pid: {:?} failed to close file: {:?}, errno={:?}", 5161496ba7bSLoGin ProcessManager::current_pcb().pid(), 517004e86ffSlogin self, 5188d72b68dSJomo r.as_ref().unwrap_err() 519004e86ffSlogin ); 520004e86ffSlogin } 521004e86ffSlogin } 522004e86ffSlogin } 523004e86ffSlogin 524004e86ffSlogin /// @brief pcb里面的文件描述符数组 52564aea4b3SGou Ngai #[derive(Debug)] 526004e86ffSlogin pub struct FileDescriptorVec { 527004e86ffSlogin /// 当前进程打开的文件描述符 5284fda81ceSLoGin fds: Vec<Option<Arc<SpinLock<File>>>>, 529004e86ffSlogin } 530004e86ffSlogin 531004e86ffSlogin impl FileDescriptorVec { 5320d9b7d92SLoGin pub const PROCESS_MAX_FD: usize = 1024; 533004e86ffSlogin 5344fda81ceSLoGin #[inline(never)] 5351496ba7bSLoGin pub fn new() -> FileDescriptorVec { 5364fda81ceSLoGin let mut data = Vec::with_capacity(FileDescriptorVec::PROCESS_MAX_FD); 5374fda81ceSLoGin data.resize(FileDescriptorVec::PROCESS_MAX_FD, None); 538004e86ffSlogin 539004e86ffSlogin // 初始化文件描述符数组结构体 5401496ba7bSLoGin return FileDescriptorVec { fds: data }; 541004e86ffSlogin } 542004e86ffSlogin 54364aea4b3SGou Ngai /// @brief 克隆一个文件描述符数组 54464aea4b3SGou Ngai /// 5451496ba7bSLoGin /// @return FileDescriptorVec 克隆后的文件描述符数组 5461496ba7bSLoGin pub fn clone(&self) -> FileDescriptorVec { 5471496ba7bSLoGin let mut res = FileDescriptorVec::new(); 54864aea4b3SGou Ngai for i in 0..FileDescriptorVec::PROCESS_MAX_FD { 54964aea4b3SGou Ngai if let Some(file) = &self.fds[i] { 5501496ba7bSLoGin if let Some(file) = file.lock().try_clone() { 5511496ba7bSLoGin res.fds[i] = Some(Arc::new(SpinLock::new(file))); 5521496ba7bSLoGin } 55364aea4b3SGou Ngai } 55464aea4b3SGou Ngai } 55564aea4b3SGou Ngai return res; 55664aea4b3SGou Ngai } 55764aea4b3SGou Ngai 558004e86ffSlogin /// @brief 判断文件描述符序号是否合法 559004e86ffSlogin /// 560004e86ffSlogin /// @return true 合法 561004e86ffSlogin /// 562004e86ffSlogin /// @return false 不合法 563004e86ffSlogin #[inline] 564004e86ffSlogin pub fn validate_fd(fd: i32) -> bool { 565004e86ffSlogin if fd < 0 || fd as usize > FileDescriptorVec::PROCESS_MAX_FD { 566004e86ffSlogin return false; 567004e86ffSlogin } else { 568004e86ffSlogin return true; 569004e86ffSlogin } 570004e86ffSlogin } 5711496ba7bSLoGin 5721496ba7bSLoGin /// 申请文件描述符,并把文件对象存入其中。 5731496ba7bSLoGin /// 5741496ba7bSLoGin /// ## 参数 5751496ba7bSLoGin /// 5761496ba7bSLoGin /// - `file` 要存放的文件对象 5771496ba7bSLoGin /// - `fd` 如果为Some(i32),表示指定要申请这个文件描述符,如果这个文件描述符已经被使用,那么返回EBADF 5781496ba7bSLoGin /// 5791496ba7bSLoGin /// ## 返回值 5801496ba7bSLoGin /// 5811496ba7bSLoGin /// - `Ok(i32)` 申请成功,返回申请到的文件描述符 5821496ba7bSLoGin /// - `Err(SystemError)` 申请失败,返回错误码,并且,file对象将被drop掉 5831496ba7bSLoGin pub fn alloc_fd(&mut self, file: File, fd: Option<i32>) -> Result<i32, SystemError> { 5841496ba7bSLoGin if fd.is_some() { 5851496ba7bSLoGin // 指定了要申请的文件描述符编号 5861496ba7bSLoGin let new_fd = fd.unwrap(); 5871496ba7bSLoGin let x = &mut self.fds[new_fd as usize]; 5881496ba7bSLoGin if x.is_none() { 5891496ba7bSLoGin *x = Some(Arc::new(SpinLock::new(file))); 5901496ba7bSLoGin return Ok(new_fd); 5911496ba7bSLoGin } else { 5921496ba7bSLoGin return Err(SystemError::EBADF); 5931496ba7bSLoGin } 5941496ba7bSLoGin } else { 5951496ba7bSLoGin // 没有指定要申请的文件描述符编号 5961496ba7bSLoGin for i in 0..FileDescriptorVec::PROCESS_MAX_FD { 5971496ba7bSLoGin if self.fds[i].is_none() { 5981496ba7bSLoGin self.fds[i] = Some(Arc::new(SpinLock::new(file))); 5991496ba7bSLoGin return Ok(i as i32); 6001496ba7bSLoGin } 6011496ba7bSLoGin } 6021496ba7bSLoGin return Err(SystemError::EMFILE); 6031496ba7bSLoGin } 6041496ba7bSLoGin } 6051496ba7bSLoGin 6061496ba7bSLoGin /// 根据文件描述符序号,获取文件结构体的Arc指针 6071496ba7bSLoGin /// 6081496ba7bSLoGin /// ## 参数 6091496ba7bSLoGin /// 6101496ba7bSLoGin /// - `fd` 文件描述符序号 6111496ba7bSLoGin pub fn get_file_by_fd(&self, fd: i32) -> Option<Arc<SpinLock<File>>> { 6121496ba7bSLoGin if !FileDescriptorVec::validate_fd(fd) { 6131496ba7bSLoGin return None; 6141496ba7bSLoGin } 6151496ba7bSLoGin return self.fds[fd as usize].clone(); 6161496ba7bSLoGin } 6171496ba7bSLoGin 6181496ba7bSLoGin /// 释放文件描述符,同时关闭文件。 6191496ba7bSLoGin /// 6201496ba7bSLoGin /// ## 参数 6211496ba7bSLoGin /// 6221496ba7bSLoGin /// - `fd` 文件描述符序号 6231496ba7bSLoGin pub fn drop_fd(&mut self, fd: i32) -> Result<(), SystemError> { 6241496ba7bSLoGin // 判断文件描述符的数字是否超过限制 6251496ba7bSLoGin if !FileDescriptorVec::validate_fd(fd) { 6261496ba7bSLoGin return Err(SystemError::EBADF); 6271496ba7bSLoGin } 6281496ba7bSLoGin 62971474bc6SLoGin self.get_file_by_fd(fd).ok_or(SystemError::EBADF)?; 6301496ba7bSLoGin 6311496ba7bSLoGin // 把文件描述符数组对应位置设置为空 6321496ba7bSLoGin let file = self.fds[fd as usize].take().unwrap(); 63334e6d6c8Syuyi2439 6341496ba7bSLoGin assert!(Arc::strong_count(&file) == 1); 6351496ba7bSLoGin return Ok(()); 6361496ba7bSLoGin } 637876cb89eSGnoCiYeH 638bf4a4899SLoGin #[allow(dead_code)] 639876cb89eSGnoCiYeH pub fn iter(&self) -> FileDescriptorIterator { 640876cb89eSGnoCiYeH return FileDescriptorIterator::new(self); 641876cb89eSGnoCiYeH } 642876cb89eSGnoCiYeH 643876cb89eSGnoCiYeH pub fn close_on_exec(&mut self) { 644876cb89eSGnoCiYeH for i in 0..FileDescriptorVec::PROCESS_MAX_FD { 645876cb89eSGnoCiYeH if let Some(file) = &self.fds[i] { 646876cb89eSGnoCiYeH let to_drop = file.lock().close_on_exec(); 647876cb89eSGnoCiYeH if to_drop { 6484ad52e57S裕依2439 if let Err(r) = self.drop_fd(i as i32) { 649876cb89eSGnoCiYeH kerror!( 650876cb89eSGnoCiYeH "Failed to close file: pid = {:?}, fd = {}, error = {:?}", 651876cb89eSGnoCiYeH ProcessManager::current_pcb().pid(), 652876cb89eSGnoCiYeH i, 653876cb89eSGnoCiYeH r 654876cb89eSGnoCiYeH ); 655876cb89eSGnoCiYeH } 656876cb89eSGnoCiYeH } 657876cb89eSGnoCiYeH } 658876cb89eSGnoCiYeH } 659876cb89eSGnoCiYeH } 660876cb89eSGnoCiYeH } 661876cb89eSGnoCiYeH 662876cb89eSGnoCiYeH #[derive(Debug)] 663876cb89eSGnoCiYeH pub struct FileDescriptorIterator<'a> { 664876cb89eSGnoCiYeH fds: &'a FileDescriptorVec, 665876cb89eSGnoCiYeH index: usize, 666876cb89eSGnoCiYeH } 667876cb89eSGnoCiYeH 668876cb89eSGnoCiYeH impl<'a> FileDescriptorIterator<'a> { 669876cb89eSGnoCiYeH pub fn new(fds: &'a FileDescriptorVec) -> Self { 670876cb89eSGnoCiYeH return Self { fds, index: 0 }; 671876cb89eSGnoCiYeH } 672876cb89eSGnoCiYeH } 673876cb89eSGnoCiYeH 674876cb89eSGnoCiYeH impl<'a> Iterator for FileDescriptorIterator<'a> { 675876cb89eSGnoCiYeH type Item = (i32, Arc<SpinLock<File>>); 676876cb89eSGnoCiYeH 677876cb89eSGnoCiYeH fn next(&mut self) -> Option<Self::Item> { 678876cb89eSGnoCiYeH while self.index < FileDescriptorVec::PROCESS_MAX_FD { 679876cb89eSGnoCiYeH let fd = self.index as i32; 680876cb89eSGnoCiYeH self.index += 1; 681876cb89eSGnoCiYeH if let Some(file) = self.fds.get_file_by_fd(fd) { 682876cb89eSGnoCiYeH return Some((fd, file)); 683876cb89eSGnoCiYeH } 684876cb89eSGnoCiYeH } 685876cb89eSGnoCiYeH return None; 686876cb89eSGnoCiYeH } 687004e86ffSlogin } 688