11074eb34SSamuel Dai use alloc::string::ToString; 2b5b571e0SLoGin use core::cmp::Ordering; 32dbef785SGnoCiYeH use core::intrinsics::unlikely; 4004e86ffSlogin use core::{any::Any, fmt::Debug}; 52eab6dd7S曾俊 use log::error; 691e9d4abSLoGin use system_error::SystemError; 7004e86ffSlogin 8004e86ffSlogin use alloc::{ 9004e86ffSlogin collections::BTreeMap, 10004e86ffSlogin string::String, 11004e86ffSlogin sync::{Arc, Weak}, 12004e86ffSlogin vec::Vec, 13004e86ffSlogin }; 14004e86ffSlogin 15c566df45SLoGin use crate::driver::base::device::device_number::DeviceNumber; 161074eb34SSamuel Dai use crate::filesystem::vfs::utils::DName; 17597ecc08STTaq use crate::filesystem::vfs::{Magic, SpecialNodeData, SuperBlock}; 182dbef785SGnoCiYeH use crate::ipc::pipe::LockedPipeInode; 19004e86ffSlogin use crate::{ 20b087521eSChiichen driver::base::block::{block_device::LBA_SIZE, disk_info::Partition, SeekFrom}, 21004e86ffSlogin filesystem::vfs::{ 2273c607aaSYJwu2023 core::generate_inode_id, 2373c607aaSYJwu2023 file::{FileMode, FilePrivateData}, 246b4e7a29SLoGin syscall::ModeType, 2540609970SGnoCiYeH FileSystem, FileType, IndexNode, InodeId, Metadata, 26004e86ffSlogin }, 27004e86ffSlogin libs::{ 28004e86ffSlogin spinlock::{SpinLock, SpinLockGuard}, 29004e86ffSlogin vec_cursor::VecCursor, 30004e86ffSlogin }, 316fc066acSJomo time::PosixTimeSpec, 32004e86ffSlogin }; 33004e86ffSlogin 342dbef785SGnoCiYeH use super::entry::FATFile; 35004e86ffSlogin use super::{ 36004e86ffSlogin bpb::{BiosParameterBlock, FATType}, 37004e86ffSlogin entry::{FATDir, FATDirEntry, FATDirIter, FATEntry}, 38004e86ffSlogin utils::RESERVED_CLUSTERS, 39004e86ffSlogin }; 40004e86ffSlogin 41597ecc08STTaq const FAT_MAX_NAMELEN: u64 = 255; 42597ecc08STTaq 43004e86ffSlogin /// FAT32文件系统的最大的文件大小 44004e86ffSlogin pub const MAX_FILE_SIZE: u64 = 0xffff_ffff; 45004e86ffSlogin 46004e86ffSlogin /// @brief 表示当前簇和上一个簇的关系的结构体 47004e86ffSlogin /// 定义这样一个结构体的原因是,FAT文件系统的文件中,前后两个簇具有关联关系。 48004e86ffSlogin #[derive(Debug, Clone, Copy, Default)] 49004e86ffSlogin pub struct Cluster { 50004e86ffSlogin pub cluster_num: u64, 51004e86ffSlogin pub parent_cluster: u64, 52004e86ffSlogin } 53004e86ffSlogin 54004e86ffSlogin impl PartialOrd for Cluster { 55004e86ffSlogin /// @brief 根据当前簇号比较大小 56004e86ffSlogin fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> { 57004e86ffSlogin return self.cluster_num.partial_cmp(&other.cluster_num); 58004e86ffSlogin } 59004e86ffSlogin } 60004e86ffSlogin 61004e86ffSlogin impl PartialEq for Cluster { 62004e86ffSlogin /// @brief 根据当前簇号比较是否相等 63004e86ffSlogin fn eq(&self, other: &Self) -> bool { 64004e86ffSlogin self.cluster_num == other.cluster_num 65004e86ffSlogin } 66004e86ffSlogin } 67004e86ffSlogin 68004e86ffSlogin impl Eq for Cluster {} 69004e86ffSlogin 70004e86ffSlogin #[derive(Debug)] 71004e86ffSlogin pub struct FATFileSystem { 72004e86ffSlogin /// 当前文件系统所在的分区 73004e86ffSlogin pub partition: Arc<Partition>, 74004e86ffSlogin /// 当前文件系统的BOPB 75004e86ffSlogin pub bpb: BiosParameterBlock, 76004e86ffSlogin /// 当前文件系统的第一个数据扇区(相对分区开始位置) 77004e86ffSlogin pub first_data_sector: u64, 78004e86ffSlogin /// 文件系统信息结构体 79004e86ffSlogin pub fs_info: Arc<LockedFATFsInfo>, 80004e86ffSlogin /// 文件系统的根inode 81004e86ffSlogin root_inode: Arc<LockedFATInode>, 82004e86ffSlogin } 83004e86ffSlogin 84004e86ffSlogin /// FAT文件系统的Inode 85004e86ffSlogin #[derive(Debug)] 86004e86ffSlogin pub struct LockedFATInode(SpinLock<FATInode>); 87004e86ffSlogin 88004e86ffSlogin #[derive(Debug)] 89004e86ffSlogin pub struct LockedFATFsInfo(SpinLock<FATFsInfo>); 90004e86ffSlogin 91004e86ffSlogin impl LockedFATFsInfo { 92004e86ffSlogin #[inline] 93004e86ffSlogin pub fn new(fs_info: FATFsInfo) -> Self { 94004e86ffSlogin return Self(SpinLock::new(fs_info)); 95004e86ffSlogin } 96004e86ffSlogin } 97004e86ffSlogin 98004e86ffSlogin #[derive(Debug)] 99004e86ffSlogin pub struct FATInode { 100004e86ffSlogin /// 指向父Inode的弱引用 101004e86ffSlogin parent: Weak<LockedFATInode>, 102004e86ffSlogin /// 指向自身的弱引用 103004e86ffSlogin self_ref: Weak<LockedFATInode>, 104004e86ffSlogin /// 子Inode的B树. 该数据结构用作缓存区。其中,它的key表示inode的名称。 105004e86ffSlogin /// 请注意,由于FAT的查询过程对大小写不敏感,因此我们选择让key全部是大写的,方便统一操作。 1061074eb34SSamuel Dai children: BTreeMap<DName, Arc<LockedFATInode>>, 107004e86ffSlogin /// 当前inode的元数据 108004e86ffSlogin metadata: Metadata, 109004e86ffSlogin /// 指向inode所在的文件系统对象的指针 110004e86ffSlogin fs: Weak<FATFileSystem>, 111004e86ffSlogin 112004e86ffSlogin /// 根据不同的Inode类型,创建不同的私有字段 113004e86ffSlogin inode_type: FATDirEntry, 1142dbef785SGnoCiYeH 1152dbef785SGnoCiYeH /// 若该节点是特殊文件节点,该字段则为真正的文件节点 1162dbef785SGnoCiYeH special_node: Option<SpecialNodeData>, 1171074eb34SSamuel Dai 1181074eb34SSamuel Dai /// 目录名 1191074eb34SSamuel Dai dname: DName, 120004e86ffSlogin } 121004e86ffSlogin 122004e86ffSlogin impl FATInode { 123004e86ffSlogin /// @brief 更新当前inode的元数据 124004e86ffSlogin pub fn update_metadata(&mut self) { 125004e86ffSlogin // todo: 更新文件的访问时间等信息 126004e86ffSlogin match &self.inode_type { 127004e86ffSlogin FATDirEntry::File(f) | FATDirEntry::VolId(f) => { 128004e86ffSlogin self.metadata.size = f.size() as i64; 129004e86ffSlogin } 130004e86ffSlogin FATDirEntry::Dir(d) => { 131004e86ffSlogin self.metadata.size = d.size(&self.fs.upgrade().unwrap().clone()) as i64; 132004e86ffSlogin } 133004e86ffSlogin FATDirEntry::UnInit => { 1342eab6dd7S曾俊 error!("update_metadata: Uninitialized FATDirEntry: {:?}", self); 135004e86ffSlogin return; 136004e86ffSlogin } 137004e86ffSlogin }; 138004e86ffSlogin } 139004e86ffSlogin 140676b8ef6SMork fn find(&mut self, name: &str) -> Result<Arc<LockedFATInode>, SystemError> { 141004e86ffSlogin match &self.inode_type { 142004e86ffSlogin FATDirEntry::Dir(d) => { 1431074eb34SSamuel Dai let dname = DName::from(name.to_uppercase()); 144004e86ffSlogin // 尝试在缓存区查找 1451074eb34SSamuel Dai if let Some(entry) = self.children.get(&dname) { 146004e86ffSlogin return Ok(entry.clone()); 147004e86ffSlogin } 148004e86ffSlogin // 在缓存区找不到 149004e86ffSlogin // 在磁盘查找 150004e86ffSlogin let fat_entry: FATDirEntry = 151004e86ffSlogin d.find_entry(name, None, None, self.fs.upgrade().unwrap())?; 152004e86ffSlogin // 创建新的inode 153004e86ffSlogin let entry_inode: Arc<LockedFATInode> = LockedFATInode::new( 1541074eb34SSamuel Dai dname.clone(), 155004e86ffSlogin self.fs.upgrade().unwrap(), 156004e86ffSlogin self.self_ref.clone(), 157004e86ffSlogin fat_entry, 158004e86ffSlogin ); 159004e86ffSlogin // 加入缓存区, 由于FAT文件系统的大小写不敏感问题,因此存入缓存区的key应当是全大写的 1601074eb34SSamuel Dai self.children.insert(dname, entry_inode.clone()); 161004e86ffSlogin return Ok(entry_inode); 162004e86ffSlogin } 163004e86ffSlogin FATDirEntry::UnInit => { 164004e86ffSlogin panic!( 165004e86ffSlogin "Uninitialized FAT Inode, fs = {:?}, inode={self:?}", 166004e86ffSlogin self.fs 167004e86ffSlogin ) 168004e86ffSlogin } 169004e86ffSlogin _ => { 170676b8ef6SMork return Err(SystemError::ENOTDIR); 171004e86ffSlogin } 172004e86ffSlogin } 173004e86ffSlogin } 174004e86ffSlogin } 175004e86ffSlogin 176004e86ffSlogin impl LockedFATInode { 177004e86ffSlogin pub fn new( 1781074eb34SSamuel Dai dname: DName, 179004e86ffSlogin fs: Arc<FATFileSystem>, 180004e86ffSlogin parent: Weak<LockedFATInode>, 181004e86ffSlogin inode_type: FATDirEntry, 182004e86ffSlogin ) -> Arc<LockedFATInode> { 183004e86ffSlogin let file_type = if let FATDirEntry::Dir(_) = inode_type { 184004e86ffSlogin FileType::Dir 185004e86ffSlogin } else { 186004e86ffSlogin FileType::File 187004e86ffSlogin }; 188004e86ffSlogin 189004e86ffSlogin let inode: Arc<LockedFATInode> = Arc::new(LockedFATInode(SpinLock::new(FATInode { 190b5b571e0SLoGin parent, 191004e86ffSlogin self_ref: Weak::default(), 192004e86ffSlogin children: BTreeMap::new(), 193004e86ffSlogin fs: Arc::downgrade(&fs), 194b5b571e0SLoGin inode_type, 195004e86ffSlogin metadata: Metadata { 196004e86ffSlogin dev_id: 0, 197004e86ffSlogin inode_id: generate_inode_id(), 198004e86ffSlogin size: 0, 199004e86ffSlogin blk_size: fs.bpb.bytes_per_sector as usize, 200004e86ffSlogin blocks: if let FATType::FAT32(_) = fs.bpb.fat_type { 201004e86ffSlogin fs.bpb.total_sectors_32 as usize 202004e86ffSlogin } else { 203004e86ffSlogin fs.bpb.total_sectors_16 as usize 204004e86ffSlogin }, 2056fc066acSJomo atime: PosixTimeSpec::default(), 2066fc066acSJomo mtime: PosixTimeSpec::default(), 2076fc066acSJomo ctime: PosixTimeSpec::default(), 208b5b571e0SLoGin file_type, 2096b4e7a29SLoGin mode: ModeType::from_bits_truncate(0o777), 210004e86ffSlogin nlinks: 1, 211004e86ffSlogin uid: 0, 212004e86ffSlogin gid: 0, 21302343d0bSLoGin raw_dev: DeviceNumber::default(), 214004e86ffSlogin }, 2152dbef785SGnoCiYeH special_node: None, 2161074eb34SSamuel Dai dname, 217004e86ffSlogin }))); 218004e86ffSlogin 219004e86ffSlogin inode.0.lock().self_ref = Arc::downgrade(&inode); 220004e86ffSlogin 221004e86ffSlogin inode.0.lock().update_metadata(); 222004e86ffSlogin 223004e86ffSlogin return inode; 224004e86ffSlogin } 225004e86ffSlogin } 226004e86ffSlogin 227004e86ffSlogin /// FsInfo结构体(内存中的一份拷贝,当卸载卷或者sync的时候,把它写入磁盘) 228004e86ffSlogin #[derive(Debug)] 229004e86ffSlogin pub struct FATFsInfo { 230004e86ffSlogin /// Lead Signature - must equal 0x41615252 231004e86ffSlogin lead_sig: u32, 232004e86ffSlogin /// Value must equal 0x61417272 233004e86ffSlogin struc_sig: u32, 234004e86ffSlogin /// 空闲簇数目 235004e86ffSlogin free_count: u32, 236004e86ffSlogin /// 第一个空闲簇的位置(不一定准确,仅供加速查找) 237004e86ffSlogin next_free: u32, 238004e86ffSlogin /// 0xAA550000 239004e86ffSlogin trail_sig: u32, 240004e86ffSlogin /// Dirty flag to flush to disk 241004e86ffSlogin dirty: bool, 242004e86ffSlogin /// FsInfo Structure 在磁盘上的字节偏移量 243004e86ffSlogin /// Not present for FAT12 and FAT16 244004e86ffSlogin offset: Option<u64>, 245004e86ffSlogin } 246004e86ffSlogin 247004e86ffSlogin impl FileSystem for FATFileSystem { 248004e86ffSlogin fn root_inode(&self) -> Arc<dyn crate::filesystem::vfs::IndexNode> { 249004e86ffSlogin return self.root_inode.clone(); 250004e86ffSlogin } 251004e86ffSlogin 252004e86ffSlogin fn info(&self) -> crate::filesystem::vfs::FsInfo { 253004e86ffSlogin todo!() 254004e86ffSlogin } 255004e86ffSlogin 256004e86ffSlogin /// @brief 本函数用于实现动态转换。 257004e86ffSlogin /// 具体的文件系统在实现本函数时,最简单的方式就是:直接返回self 258004e86ffSlogin fn as_any_ref(&self) -> &dyn Any { 259004e86ffSlogin self 260004e86ffSlogin } 2611d37ca6dSDonkey Kane 2621d37ca6dSDonkey Kane fn name(&self) -> &str { 2631d37ca6dSDonkey Kane "fat" 2641d37ca6dSDonkey Kane } 265597ecc08STTaq 266597ecc08STTaq fn super_block(&self) -> SuperBlock { 267597ecc08STTaq SuperBlock::new( 268597ecc08STTaq Magic::FAT_MAGIC, 269597ecc08STTaq self.bpb.bytes_per_sector.into(), 270597ecc08STTaq FAT_MAX_NAMELEN, 271597ecc08STTaq ) 272597ecc08STTaq } 273004e86ffSlogin } 274004e86ffSlogin 275004e86ffSlogin impl FATFileSystem { 2762286eda6SWaferJay /// FAT12允许的最大簇号 2772286eda6SWaferJay pub const FAT12_MAX_CLUSTER: u32 = 0xFF5; 2782286eda6SWaferJay /// FAT16允许的最大簇号 2792286eda6SWaferJay pub const FAT16_MAX_CLUSTER: u32 = 0xFFF5; 2802286eda6SWaferJay /// FAT32允许的最大簇号 2812286eda6SWaferJay pub const FAT32_MAX_CLUSTER: u32 = 0x0FFFFFF7; 2822286eda6SWaferJay 283676b8ef6SMork pub fn new(partition: Arc<Partition>) -> Result<Arc<FATFileSystem>, SystemError> { 284004e86ffSlogin let bpb = BiosParameterBlock::new(partition.clone())?; 285004e86ffSlogin 286004e86ffSlogin // 从磁盘上读取FAT32文件系统的FsInfo结构体 287004e86ffSlogin let fs_info: FATFsInfo = match bpb.fat_type { 288004e86ffSlogin FATType::FAT32(bpb32) => { 289004e86ffSlogin let fs_info_in_disk_bytes_offset = partition.lba_start * LBA_SIZE as u64 290004e86ffSlogin + bpb32.fs_info as u64 * bpb.bytes_per_sector as u64; 291004e86ffSlogin FATFsInfo::new( 292004e86ffSlogin partition.clone(), 293004e86ffSlogin fs_info_in_disk_bytes_offset, 294004e86ffSlogin bpb.bytes_per_sector as usize, 295004e86ffSlogin )? 296004e86ffSlogin } 297004e86ffSlogin _ => FATFsInfo::default(), 298004e86ffSlogin }; 299004e86ffSlogin 300004e86ffSlogin // 根目录项占用的扇区数(向上取整) 301004e86ffSlogin let root_dir_sectors: u64 = ((bpb.root_entries_cnt as u64 * 32) 302004e86ffSlogin + (bpb.bytes_per_sector as u64 - 1)) 303004e86ffSlogin / (bpb.bytes_per_sector as u64); 304004e86ffSlogin 305004e86ffSlogin // FAT表大小(单位:扇区) 306004e86ffSlogin let fat_size = if bpb.fat_size_16 != 0 { 307004e86ffSlogin bpb.fat_size_16 as u64 308004e86ffSlogin } else { 309004e86ffSlogin match bpb.fat_type { 310004e86ffSlogin FATType::FAT32(x) => x.fat_size_32 as u64, 311004e86ffSlogin _ => { 3122eab6dd7S曾俊 error!("FAT12 and FAT16 volumes should have non-zero BPB_FATSz16"); 313676b8ef6SMork return Err(SystemError::EINVAL); 314004e86ffSlogin } 315004e86ffSlogin } 316004e86ffSlogin }; 317004e86ffSlogin 318004e86ffSlogin let first_data_sector = 319004e86ffSlogin bpb.rsvd_sec_cnt as u64 + (bpb.num_fats as u64 * fat_size) + root_dir_sectors; 320004e86ffSlogin 321004e86ffSlogin // 创建文件系统的根节点 322004e86ffSlogin let root_inode: Arc<LockedFATInode> = Arc::new(LockedFATInode(SpinLock::new(FATInode { 323004e86ffSlogin parent: Weak::default(), 324004e86ffSlogin self_ref: Weak::default(), 325004e86ffSlogin children: BTreeMap::new(), 326004e86ffSlogin fs: Weak::default(), 327004e86ffSlogin inode_type: FATDirEntry::UnInit, 328004e86ffSlogin metadata: Metadata { 329004e86ffSlogin dev_id: 0, 330004e86ffSlogin inode_id: generate_inode_id(), 331004e86ffSlogin size: 0, 332004e86ffSlogin blk_size: bpb.bytes_per_sector as usize, 333004e86ffSlogin blocks: if let FATType::FAT32(_) = bpb.fat_type { 334004e86ffSlogin bpb.total_sectors_32 as usize 335004e86ffSlogin } else { 336004e86ffSlogin bpb.total_sectors_16 as usize 337004e86ffSlogin }, 3386fc066acSJomo atime: PosixTimeSpec::default(), 3396fc066acSJomo mtime: PosixTimeSpec::default(), 3406fc066acSJomo ctime: PosixTimeSpec::default(), 341004e86ffSlogin file_type: FileType::Dir, 3426b4e7a29SLoGin mode: ModeType::from_bits_truncate(0o777), 343004e86ffSlogin nlinks: 1, 344004e86ffSlogin uid: 0, 345004e86ffSlogin gid: 0, 34602343d0bSLoGin raw_dev: DeviceNumber::default(), 347004e86ffSlogin }, 3482dbef785SGnoCiYeH special_node: None, 3491074eb34SSamuel Dai dname: DName::default(), 350004e86ffSlogin }))); 351004e86ffSlogin 352004e86ffSlogin let result: Arc<FATFileSystem> = Arc::new(FATFileSystem { 353b5b571e0SLoGin partition, 354004e86ffSlogin bpb, 355004e86ffSlogin first_data_sector, 356004e86ffSlogin fs_info: Arc::new(LockedFATFsInfo::new(fs_info)), 357b5b571e0SLoGin root_inode, 358004e86ffSlogin }); 359004e86ffSlogin 360004e86ffSlogin // 对root inode加锁,并继续完成初始化工作 361004e86ffSlogin let mut root_guard: SpinLockGuard<FATInode> = result.root_inode.0.lock(); 362004e86ffSlogin root_guard.inode_type = FATDirEntry::Dir(result.root_dir()); 363004e86ffSlogin root_guard.parent = Arc::downgrade(&result.root_inode); 364004e86ffSlogin root_guard.self_ref = Arc::downgrade(&result.root_inode); 365004e86ffSlogin root_guard.fs = Arc::downgrade(&result); 366004e86ffSlogin // 释放锁 367004e86ffSlogin drop(root_guard); 368004e86ffSlogin 369004e86ffSlogin return Ok(result); 370004e86ffSlogin } 371004e86ffSlogin 372004e86ffSlogin /// @brief 计算每个簇有多少个字节 373004e86ffSlogin #[inline] 374004e86ffSlogin pub fn bytes_per_cluster(&self) -> u64 { 375004e86ffSlogin return (self.bpb.bytes_per_sector as u64) * (self.bpb.sector_per_cluster as u64); 376004e86ffSlogin } 377004e86ffSlogin 378004e86ffSlogin /// @brief 读取当前簇在FAT表中存储的信息 379004e86ffSlogin /// 380004e86ffSlogin /// @param cluster 当前簇 381004e86ffSlogin /// 382004e86ffSlogin /// @return Ok(FATEntry) 当前簇在FAT表中,存储的信息。(详情见FATEntry的注释) 383676b8ef6SMork /// @return Err(SystemError) 错误码 384676b8ef6SMork pub fn get_fat_entry(&self, cluster: Cluster) -> Result<FATEntry, SystemError> { 385004e86ffSlogin let current_cluster = cluster.cluster_num; 3866d81180bSLoGin if current_cluster < 2 { 3876d81180bSLoGin // 0号簇和1号簇是保留簇,不允许用户使用 3886d81180bSLoGin return Err(SystemError::EINVAL); 3896d81180bSLoGin } 390004e86ffSlogin 391004e86ffSlogin let fat_type: FATType = self.bpb.fat_type; 392004e86ffSlogin // 获取FAT表的起始扇区(相对分区起始扇区的偏移量) 393004e86ffSlogin let fat_start_sector = self.fat_start_sector(); 394004e86ffSlogin let bytes_per_sec = self.bpb.bytes_per_sector as u64; 395004e86ffSlogin 396004e86ffSlogin // cluster对应的FAT表项在分区内的字节偏移量 397004e86ffSlogin let fat_bytes_offset = 398004e86ffSlogin fat_type.get_fat_bytes_offset(cluster, fat_start_sector, bytes_per_sec); 399004e86ffSlogin 400004e86ffSlogin // FAT表项所在的LBA地址 401004e86ffSlogin // let fat_ent_lba = self.get_lba_from_offset(self.bytes_to_sector(fat_bytes_offset)); 402004e86ffSlogin let fat_ent_lba = self.partition.lba_start + fat_bytes_offset / LBA_SIZE as u64; 403004e86ffSlogin 404004e86ffSlogin // FAT表项在逻辑块内的字节偏移量 405004e86ffSlogin let blk_offset = self.get_in_block_offset(fat_bytes_offset); 406004e86ffSlogin 407b5b571e0SLoGin let mut v: Vec<u8> = vec![0; self.bpb.bytes_per_sector as usize]; 408004e86ffSlogin self.partition 409004e86ffSlogin .disk() 410b5b571e0SLoGin .read_at(fat_ent_lba as usize, self.lba_per_sector(), &mut v)?; 411004e86ffSlogin 412004e86ffSlogin let mut cursor = VecCursor::new(v); 413004e86ffSlogin cursor.seek(SeekFrom::SeekSet(blk_offset as i64))?; 414004e86ffSlogin 415004e86ffSlogin let res: FATEntry = match self.bpb.fat_type { 416004e86ffSlogin FATType::FAT12(_) => { 417004e86ffSlogin let mut entry = cursor.read_u16()?; 418004e86ffSlogin // 由于FAT12文件系统的FAT表,每个entry占用1.5字节,因此奇数的簇需要取高12位的值。 419004e86ffSlogin if (current_cluster & 1) > 0 { 420004e86ffSlogin entry >>= 4; 421004e86ffSlogin } else { 422004e86ffSlogin entry &= 0x0fff; 423004e86ffSlogin } 424004e86ffSlogin 425004e86ffSlogin if entry == 0 { 426004e86ffSlogin FATEntry::Unused 427004e86ffSlogin } else if entry == 0x0ff7 { 428004e86ffSlogin FATEntry::Bad 429004e86ffSlogin } else if entry >= 0x0ff8 { 430004e86ffSlogin FATEntry::EndOfChain 431004e86ffSlogin } else { 432004e86ffSlogin FATEntry::Next(Cluster { 433004e86ffSlogin cluster_num: entry as u64, 434004e86ffSlogin parent_cluster: current_cluster, 435004e86ffSlogin }) 436004e86ffSlogin } 437004e86ffSlogin } 438004e86ffSlogin FATType::FAT16(_) => { 439004e86ffSlogin let entry = cursor.read_u16()?; 440004e86ffSlogin 441004e86ffSlogin if entry == 0 { 442004e86ffSlogin FATEntry::Unused 443004e86ffSlogin } else if entry == 0xfff7 { 444004e86ffSlogin FATEntry::Bad 445004e86ffSlogin } else if entry >= 0xfff8 { 446004e86ffSlogin FATEntry::EndOfChain 447004e86ffSlogin } else { 448004e86ffSlogin FATEntry::Next(Cluster { 449004e86ffSlogin cluster_num: entry as u64, 450004e86ffSlogin parent_cluster: current_cluster, 451004e86ffSlogin }) 452004e86ffSlogin } 453004e86ffSlogin } 454004e86ffSlogin FATType::FAT32(_) => { 455004e86ffSlogin let entry = cursor.read_u32()? & 0x0fffffff; 456004e86ffSlogin 457004e86ffSlogin match entry { 458b5b571e0SLoGin _n if (0x0ffffff7..=0x0fffffff).contains(¤t_cluster) => { 459004e86ffSlogin // 当前簇号不是一个能被获得的簇(可能是文件系统出错了) 4602eab6dd7S曾俊 error!("FAT32 get fat entry: current cluster number [{}] is not an allocatable cluster number.", current_cluster); 461004e86ffSlogin FATEntry::Bad 462004e86ffSlogin } 463004e86ffSlogin 0 => FATEntry::Unused, 464004e86ffSlogin 0x0ffffff7 => FATEntry::Bad, 465004e86ffSlogin 0x0ffffff8..=0x0fffffff => FATEntry::EndOfChain, 466004e86ffSlogin _n => FATEntry::Next(Cluster { 467004e86ffSlogin cluster_num: entry as u64, 468004e86ffSlogin parent_cluster: current_cluster, 469004e86ffSlogin }), 470004e86ffSlogin } 471004e86ffSlogin } 472004e86ffSlogin }; 473004e86ffSlogin return Ok(res); 474004e86ffSlogin } 475004e86ffSlogin 476004e86ffSlogin /// @brief 读取当前簇在FAT表中存储的信息(直接返回读取到的值,而不加处理) 477004e86ffSlogin /// 478004e86ffSlogin /// @param cluster 当前簇 479004e86ffSlogin /// 480004e86ffSlogin /// @return Ok(u64) 当前簇在FAT表中,存储的信息。 481676b8ef6SMork /// @return Err(SystemError) 错误码 482676b8ef6SMork pub fn get_fat_entry_raw(&self, cluster: Cluster) -> Result<u64, SystemError> { 483004e86ffSlogin let current_cluster = cluster.cluster_num; 484004e86ffSlogin 485004e86ffSlogin let fat_type: FATType = self.bpb.fat_type; 486004e86ffSlogin // 获取FAT表的起始扇区(相对分区起始扇区的偏移量) 487004e86ffSlogin let fat_start_sector = self.fat_start_sector(); 488004e86ffSlogin let bytes_per_sec = self.bpb.bytes_per_sector as u64; 489004e86ffSlogin 490004e86ffSlogin // cluster对应的FAT表项在分区内的字节偏移量 491004e86ffSlogin let fat_bytes_offset = 492004e86ffSlogin fat_type.get_fat_bytes_offset(cluster, fat_start_sector, bytes_per_sec); 493004e86ffSlogin 494004e86ffSlogin // FAT表项所在的LBA地址 495004e86ffSlogin let fat_ent_lba = self.get_lba_from_offset(self.bytes_to_sector(fat_bytes_offset)); 496004e86ffSlogin 497004e86ffSlogin // FAT表项在逻辑块内的字节偏移量 498004e86ffSlogin let blk_offset = self.get_in_block_offset(fat_bytes_offset); 499004e86ffSlogin 500b5b571e0SLoGin let mut v: Vec<u8> = vec![0; self.bpb.bytes_per_sector as usize]; 501004e86ffSlogin self.partition 502004e86ffSlogin .disk() 503b5b571e0SLoGin .read_at(fat_ent_lba, self.lba_per_sector(), &mut v)?; 504004e86ffSlogin 505004e86ffSlogin let mut cursor = VecCursor::new(v); 506004e86ffSlogin cursor.seek(SeekFrom::SeekSet(blk_offset as i64))?; 507004e86ffSlogin 508004e86ffSlogin let res = match self.bpb.fat_type { 509004e86ffSlogin FATType::FAT12(_) => { 510004e86ffSlogin let mut entry = cursor.read_u16()?; 511004e86ffSlogin entry = if (current_cluster & 0x0001) > 0 { 512004e86ffSlogin entry >> 4 513004e86ffSlogin } else { 514004e86ffSlogin entry & 0x0fff 515004e86ffSlogin }; 516004e86ffSlogin entry as u64 517004e86ffSlogin } 518004e86ffSlogin FATType::FAT16(_) => { 519004e86ffSlogin let entry = (cursor.read_u16()?) as u64; 520004e86ffSlogin entry 521004e86ffSlogin } 522004e86ffSlogin FATType::FAT32(_) => { 523004e86ffSlogin let entry = cursor.read_u32()? & 0x0fff_ffff; 524004e86ffSlogin entry as u64 525004e86ffSlogin } 526004e86ffSlogin }; 527004e86ffSlogin 528004e86ffSlogin return Ok(res); 529004e86ffSlogin } 530004e86ffSlogin 531004e86ffSlogin /// @brief 获取当前文件系统的root inode,在磁盘上的字节偏移量 532004e86ffSlogin pub fn root_dir_bytes_offset(&self) -> u64 { 533004e86ffSlogin match self.bpb.fat_type { 534004e86ffSlogin FATType::FAT32(s) => { 535004e86ffSlogin let first_sec_cluster: u64 = (s.root_cluster as u64 - 2) 536004e86ffSlogin * (self.bpb.sector_per_cluster as u64) 537004e86ffSlogin + self.first_data_sector; 538004e86ffSlogin return (self.get_lba_from_offset(first_sec_cluster) * LBA_SIZE) as u64; 539004e86ffSlogin } 540004e86ffSlogin _ => { 541004e86ffSlogin let root_sec = (self.bpb.rsvd_sec_cnt as u64) 542004e86ffSlogin + (self.bpb.num_fats as u64) * (self.bpb.fat_size_16 as u64); 543004e86ffSlogin return (self.get_lba_from_offset(root_sec) * LBA_SIZE) as u64; 544004e86ffSlogin } 545004e86ffSlogin } 546004e86ffSlogin } 547004e86ffSlogin 548004e86ffSlogin /// @brief 获取当前文件系统的根目录项区域的结束位置,在磁盘上的字节偏移量。 549004e86ffSlogin /// 请注意,当前函数只对FAT12/FAT16生效。对于FAT32,返回None 550004e86ffSlogin pub fn root_dir_end_bytes_offset(&self) -> Option<u64> { 551004e86ffSlogin match self.bpb.fat_type { 552004e86ffSlogin FATType::FAT12(_) | FATType::FAT16(_) => { 553004e86ffSlogin return Some( 554004e86ffSlogin self.root_dir_bytes_offset() + (self.bpb.root_entries_cnt as u64) * 32, 555004e86ffSlogin ); 556004e86ffSlogin } 557004e86ffSlogin _ => { 558004e86ffSlogin return None; 559004e86ffSlogin } 560004e86ffSlogin } 561004e86ffSlogin } 562004e86ffSlogin 563004e86ffSlogin /// @brief 获取簇在磁盘内的字节偏移量(相对磁盘起始位置。注意,不是分区内偏移量) 564004e86ffSlogin pub fn cluster_bytes_offset(&self, cluster: Cluster) -> u64 { 565004e86ffSlogin if cluster.cluster_num >= 2 { 566004e86ffSlogin // 指定簇的第一个扇区号 567004e86ffSlogin let first_sec_of_cluster = (cluster.cluster_num - 2) 568004e86ffSlogin * (self.bpb.sector_per_cluster as u64) 569004e86ffSlogin + self.first_data_sector; 570004e86ffSlogin return (self.get_lba_from_offset(first_sec_of_cluster) * LBA_SIZE) as u64; 571004e86ffSlogin } else { 572004e86ffSlogin return 0; 573004e86ffSlogin } 574004e86ffSlogin } 575004e86ffSlogin 576004e86ffSlogin /// @brief 获取一个空闲簇 577004e86ffSlogin /// 578004e86ffSlogin /// @param prev_cluster 簇链的前一个簇。本函数将会把新获取的簇,连接到它的后面。 579004e86ffSlogin /// 580004e86ffSlogin /// @return Ok(Cluster) 新获取的空闲簇 581676b8ef6SMork /// @return Err(SystemError) 错误码 582676b8ef6SMork pub fn allocate_cluster(&self, prev_cluster: Option<Cluster>) -> Result<Cluster, SystemError> { 583004e86ffSlogin let end_cluster: Cluster = self.max_cluster_number(); 584004e86ffSlogin let start_cluster: Cluster = match self.bpb.fat_type { 585004e86ffSlogin FATType::FAT32(_) => { 586b5b571e0SLoGin let next_free: u64 = self.fs_info.0.lock().next_free().unwrap_or(0xffffffff); 587004e86ffSlogin if next_free < end_cluster.cluster_num { 588004e86ffSlogin Cluster::new(next_free) 589004e86ffSlogin } else { 590004e86ffSlogin Cluster::new(RESERVED_CLUSTERS as u64) 591004e86ffSlogin } 592004e86ffSlogin } 593004e86ffSlogin _ => Cluster::new(RESERVED_CLUSTERS as u64), 594004e86ffSlogin }; 595004e86ffSlogin 596004e86ffSlogin // 寻找一个空的簇 597004e86ffSlogin let free_cluster: Cluster = match self.get_free_cluster(start_cluster, end_cluster) { 598004e86ffSlogin Ok(c) => c, 599004e86ffSlogin Err(_) if start_cluster.cluster_num > RESERVED_CLUSTERS as u64 => { 600004e86ffSlogin self.get_free_cluster(Cluster::new(RESERVED_CLUSTERS as u64), end_cluster)? 601004e86ffSlogin } 602004e86ffSlogin Err(e) => return Err(e), 603004e86ffSlogin }; 604004e86ffSlogin 605004e86ffSlogin self.set_entry(free_cluster, FATEntry::EndOfChain)?; 606004e86ffSlogin // 减少空闲簇计数 607004e86ffSlogin self.fs_info.0.lock().update_free_count_delta(-1); 608004e86ffSlogin // 更新搜索空闲簇的参考量 609004e86ffSlogin self.fs_info 610004e86ffSlogin .0 611004e86ffSlogin .lock() 612004e86ffSlogin .update_next_free((free_cluster.cluster_num + 1) as u32); 613004e86ffSlogin 614004e86ffSlogin // 如果这个空闲簇不是簇链的第一个簇,那么把当前簇跟前一个簇连上。 615004e86ffSlogin if let Some(prev_cluster) = prev_cluster { 6162eab6dd7S曾俊 // debug!("set entry, prev ={prev_cluster:?}, next = {free_cluster:?}"); 617004e86ffSlogin self.set_entry(prev_cluster, FATEntry::Next(free_cluster))?; 618004e86ffSlogin } 619004e86ffSlogin // 清空新获取的这个簇 620004e86ffSlogin self.zero_cluster(free_cluster)?; 621004e86ffSlogin return Ok(free_cluster); 622004e86ffSlogin } 623004e86ffSlogin 624004e86ffSlogin /// @brief 释放簇链上的所有簇 625004e86ffSlogin /// 626004e86ffSlogin /// @param start_cluster 簇链的第一个簇 627676b8ef6SMork pub fn deallocate_cluster_chain(&self, start_cluster: Cluster) -> Result<(), SystemError> { 628004e86ffSlogin let clusters: Vec<Cluster> = self.clusters(start_cluster); 629004e86ffSlogin for c in clusters { 630004e86ffSlogin self.deallocate_cluster(c)?; 631004e86ffSlogin } 632004e86ffSlogin return Ok(()); 633004e86ffSlogin } 634004e86ffSlogin 635004e86ffSlogin /// @brief 释放簇 636004e86ffSlogin /// 637004e86ffSlogin /// @param 要释放的簇 638676b8ef6SMork pub fn deallocate_cluster(&self, cluster: Cluster) -> Result<(), SystemError> { 639004e86ffSlogin let entry: FATEntry = self.get_fat_entry(cluster)?; 640004e86ffSlogin // 如果不是坏簇 641004e86ffSlogin if entry != FATEntry::Bad { 642004e86ffSlogin self.set_entry(cluster, FATEntry::Unused)?; 643004e86ffSlogin self.fs_info.0.lock().update_free_count_delta(1); 644004e86ffSlogin // 安全选项:清空被释放的簇 645004e86ffSlogin #[cfg(feature = "secure")] 646004e86ffSlogin self.zero_cluster(cluster)?; 647004e86ffSlogin return Ok(()); 648004e86ffSlogin } else { 649004e86ffSlogin // 不能释放坏簇 6502eab6dd7S曾俊 error!("Bad clusters cannot be freed."); 651676b8ef6SMork return Err(SystemError::EFAULT); 652004e86ffSlogin } 653004e86ffSlogin } 654004e86ffSlogin 655004e86ffSlogin /// @brief 获取文件系统的根目录项 656004e86ffSlogin pub fn root_dir(&self) -> FATDir { 657004e86ffSlogin match self.bpb.fat_type { 658004e86ffSlogin FATType::FAT32(s) => { 659004e86ffSlogin return FATDir { 660004e86ffSlogin first_cluster: Cluster::new(s.root_cluster as u64), 661004e86ffSlogin dir_name: String::from("/"), 662004e86ffSlogin root_offset: None, 663004e86ffSlogin short_dir_entry: None, 664004e86ffSlogin loc: None, 665004e86ffSlogin }; 666004e86ffSlogin } 667004e86ffSlogin _ => FATDir { 668004e86ffSlogin first_cluster: Cluster::new(0), 669004e86ffSlogin dir_name: String::from("/"), 670004e86ffSlogin root_offset: Some(self.root_dir_bytes_offset()), 671004e86ffSlogin short_dir_entry: None, 672004e86ffSlogin loc: None, 673004e86ffSlogin }, 674004e86ffSlogin } 675004e86ffSlogin } 676004e86ffSlogin 677004e86ffSlogin /// @brief 获取FAT表的起始扇区(相对分区起始扇区的偏移量) 678004e86ffSlogin pub fn fat_start_sector(&self) -> u64 { 679004e86ffSlogin let active_fat = self.active_fat(); 680004e86ffSlogin let fat_size = self.fat_size(); 681004e86ffSlogin return self.bpb.rsvd_sec_cnt as u64 + active_fat * fat_size; 682004e86ffSlogin } 683004e86ffSlogin 684004e86ffSlogin /// @brief 获取当前活动的FAT表 685004e86ffSlogin pub fn active_fat(&self) -> u64 { 686004e86ffSlogin if self.mirroring_enabled() { 687004e86ffSlogin return 0; 688004e86ffSlogin } else { 689004e86ffSlogin match self.bpb.fat_type { 690004e86ffSlogin FATType::FAT32(bpb32) => { 691004e86ffSlogin return (bpb32.ext_flags & 0x0f) as u64; 692004e86ffSlogin } 693004e86ffSlogin _ => { 694004e86ffSlogin return 0; 695004e86ffSlogin } 696004e86ffSlogin } 697004e86ffSlogin } 698004e86ffSlogin } 699004e86ffSlogin 700004e86ffSlogin /// @brief 获取当前文件系统的每个FAT表的大小 701004e86ffSlogin pub fn fat_size(&self) -> u64 { 702004e86ffSlogin if self.bpb.fat_size_16 != 0 { 703004e86ffSlogin return self.bpb.fat_size_16 as u64; 704004e86ffSlogin } else { 705004e86ffSlogin match self.bpb.fat_type { 706004e86ffSlogin FATType::FAT32(bpb32) => { 707004e86ffSlogin return bpb32.fat_size_32 as u64; 708004e86ffSlogin } 709004e86ffSlogin 710004e86ffSlogin _ => { 711004e86ffSlogin panic!("FAT12 and FAT16 volumes should have non-zero BPB_FATSz16"); 712004e86ffSlogin } 713004e86ffSlogin } 714004e86ffSlogin } 715004e86ffSlogin } 716004e86ffSlogin 717004e86ffSlogin /// @brief 判断当前文件系统是否启用了FAT表镜像 718004e86ffSlogin pub fn mirroring_enabled(&self) -> bool { 719004e86ffSlogin match self.bpb.fat_type { 720004e86ffSlogin FATType::FAT32(bpb32) => { 721004e86ffSlogin return (bpb32.ext_flags & 0x80) == 0; 722004e86ffSlogin } 723004e86ffSlogin _ => { 724004e86ffSlogin return false; 725004e86ffSlogin } 726004e86ffSlogin } 727004e86ffSlogin } 728004e86ffSlogin 729004e86ffSlogin /// @brief 根据分区内的扇区偏移量,获得在磁盘上的LBA地址 730004e86ffSlogin #[inline] 731004e86ffSlogin pub fn get_lba_from_offset(&self, in_partition_sec_offset: u64) -> usize { 732004e86ffSlogin return (self.partition.lba_start 733004e86ffSlogin + in_partition_sec_offset * (self.bpb.bytes_per_sector as u64 / LBA_SIZE as u64)) 734004e86ffSlogin as usize; 735004e86ffSlogin } 736004e86ffSlogin 737004e86ffSlogin /// @brief 获取每个扇区占用多少个LBA 738004e86ffSlogin #[inline] 739004e86ffSlogin pub fn lba_per_sector(&self) -> usize { 740004e86ffSlogin return self.bpb.bytes_per_sector as usize / LBA_SIZE; 741004e86ffSlogin } 742004e86ffSlogin 743004e86ffSlogin /// @brief 将分区内字节偏移量转换为扇区偏移量 744004e86ffSlogin #[inline] 745004e86ffSlogin pub fn bytes_to_sector(&self, in_partition_bytes_offset: u64) -> u64 { 746004e86ffSlogin return in_partition_bytes_offset / (self.bpb.bytes_per_sector as u64); 747004e86ffSlogin } 748004e86ffSlogin 749004e86ffSlogin /// @brief 根据磁盘上的字节偏移量,获取对应位置在分区内的字节偏移量 750004e86ffSlogin #[inline] 751004e86ffSlogin pub fn get_in_partition_bytes_offset(&self, disk_bytes_offset: u64) -> u64 { 752004e86ffSlogin return disk_bytes_offset - (self.partition.lba_start * LBA_SIZE as u64); 753004e86ffSlogin } 754004e86ffSlogin 755004e86ffSlogin /// @brief 根据字节偏移量计算在逻辑块内的字节偏移量 756004e86ffSlogin #[inline] 757004e86ffSlogin pub fn get_in_block_offset(&self, bytes_offset: u64) -> u64 { 758004e86ffSlogin return bytes_offset % LBA_SIZE as u64; 759004e86ffSlogin } 760004e86ffSlogin 761004e86ffSlogin /// @brief 获取在FAT表中,以start_cluster开头的FAT链的所有簇的信息 762004e86ffSlogin /// 763004e86ffSlogin /// @param start_cluster 整个FAT链的起始簇号 764004e86ffSlogin pub fn clusters(&self, start_cluster: Cluster) -> Vec<Cluster> { 765004e86ffSlogin return self.cluster_iter(start_cluster).collect(); 766004e86ffSlogin } 767004e86ffSlogin 768004e86ffSlogin /// @brief 获取在FAT表中,以start_cluster开头的FAT链的长度(总计经过多少个簇) 769004e86ffSlogin /// 770004e86ffSlogin /// @param start_cluster 整个FAT链的起始簇号 771004e86ffSlogin pub fn num_clusters_chain(&self, start_cluster: Cluster) -> u64 { 772004e86ffSlogin return self 773004e86ffSlogin .cluster_iter(start_cluster) 774004e86ffSlogin .fold(0, |size, _cluster| size + 1); 775004e86ffSlogin } 776004e86ffSlogin /// @brief 获取一个簇迭代器对象 777004e86ffSlogin /// 778004e86ffSlogin /// @param start_cluster 整个FAT链的起始簇号 779004e86ffSlogin fn cluster_iter(&self, start_cluster: Cluster) -> ClusterIter { 780004e86ffSlogin return ClusterIter { 781004e86ffSlogin current_cluster: Some(start_cluster), 782004e86ffSlogin fs: self, 783004e86ffSlogin }; 784004e86ffSlogin } 785004e86ffSlogin 786004e86ffSlogin /// @brief 获取从start_cluster开始的簇链中,第n个簇的信息。(请注意,下标从0开始) 787004e86ffSlogin #[inline] 788004e86ffSlogin pub fn get_cluster_by_relative(&self, start_cluster: Cluster, n: usize) -> Option<Cluster> { 789b5b571e0SLoGin return self.cluster_iter(start_cluster).nth(n); 790004e86ffSlogin } 791004e86ffSlogin 792004e86ffSlogin /// @brief 获取整个簇链的最后一个簇 793004e86ffSlogin #[inline] 794004e86ffSlogin pub fn get_last_cluster(&self, start_cluster: Cluster) -> Option<Cluster> { 795004e86ffSlogin return self.cluster_iter(start_cluster).last(); 796004e86ffSlogin } 797004e86ffSlogin 798004e86ffSlogin /// @brief 判断FAT文件系统的shut bit是否正常。 799004e86ffSlogin /// shut bit 表示文件系统是否正常卸载。如果这一位是1,则表示这个卷是“干净的” 800004e86ffSlogin /// 参考资料:https://thestarman.pcministry.com/DOS/DirtyShutdownFlag.html 801004e86ffSlogin /// 802004e86ffSlogin /// @return Ok(true) 正常 803004e86ffSlogin /// @return Ok(false) 不正常 804676b8ef6SMork /// @return Err(SystemError) 在判断时发生错误 80591e9d4abSLoGin #[allow(dead_code)] 806676b8ef6SMork pub fn is_shut_bit_ok(&mut self) -> Result<bool, SystemError> { 807004e86ffSlogin match self.bpb.fat_type { 808004e86ffSlogin FATType::FAT32(_) => { 809004e86ffSlogin // 对于FAT32, error bit位于第一个扇区的第8字节。 810004e86ffSlogin let bit = self.get_fat_entry_raw(Cluster::new(1))? & 0x0800_0000; 811004e86ffSlogin return Ok(bit > 0); 812004e86ffSlogin } 813004e86ffSlogin FATType::FAT16(_) => { 814004e86ffSlogin let bit = self.get_fat_entry_raw(Cluster::new(1))? & 0x8000; 815004e86ffSlogin return Ok(bit > 0); 816004e86ffSlogin } 817004e86ffSlogin _ => return Ok(true), 818004e86ffSlogin } 819004e86ffSlogin } 820004e86ffSlogin 821004e86ffSlogin /// @brief 判断FAT文件系统的hard error bit是否正常。 822004e86ffSlogin /// 如果此位为0,则文件系统驱动程序在上次安装卷时遇到磁盘 I/O 错误,这表明 823004e86ffSlogin /// 卷上的某些扇区可能已损坏。 824004e86ffSlogin /// 参考资料:https://thestarman.pcministry.com/DOS/DirtyShutdownFlag.html 825004e86ffSlogin /// 826004e86ffSlogin /// @return Ok(true) 正常 827004e86ffSlogin /// @return Ok(false) 不正常 828676b8ef6SMork /// @return Err(SystemError) 在判断时发生错误 829676b8ef6SMork pub fn is_hard_error_bit_ok(&mut self) -> Result<bool, SystemError> { 830004e86ffSlogin match self.bpb.fat_type { 831004e86ffSlogin FATType::FAT32(_) => { 832004e86ffSlogin let bit = self.get_fat_entry_raw(Cluster::new(1))? & 0x0400_0000; 833004e86ffSlogin return Ok(bit > 0); 834004e86ffSlogin } 835004e86ffSlogin FATType::FAT16(_) => { 836004e86ffSlogin let bit = self.get_fat_entry_raw(Cluster::new(1))? & 0x4000; 837004e86ffSlogin return Ok(bit > 0); 838004e86ffSlogin } 839004e86ffSlogin _ => return Ok(true), 840004e86ffSlogin } 841004e86ffSlogin } 842004e86ffSlogin 843004e86ffSlogin /// @brief 设置文件系统的shut bit为正常状态 844004e86ffSlogin /// 参考资料:https://thestarman.pcministry.com/DOS/DirtyShutdownFlag.html 845004e86ffSlogin /// 846004e86ffSlogin /// @return Ok(()) 设置成功 847676b8ef6SMork /// @return Err(SystemError) 在设置过程中,出现错误 848676b8ef6SMork pub fn set_shut_bit_ok(&mut self) -> Result<(), SystemError> { 849004e86ffSlogin match self.bpb.fat_type { 850004e86ffSlogin FATType::FAT32(_) => { 851004e86ffSlogin let raw_entry = self.get_fat_entry_raw(Cluster::new(1))? | 0x0800_0000; 852004e86ffSlogin self.set_entry(Cluster::new(1), FATEntry::Next(Cluster::new(raw_entry)))?; 853004e86ffSlogin 854004e86ffSlogin return Ok(()); 855004e86ffSlogin } 856004e86ffSlogin 857004e86ffSlogin FATType::FAT16(_) => { 858004e86ffSlogin let raw_entry = self.get_fat_entry_raw(Cluster::new(1))? | 0x8000; 859004e86ffSlogin self.set_entry(Cluster::new(1), FATEntry::Next(Cluster::new(raw_entry)))?; 860004e86ffSlogin return Ok(()); 861004e86ffSlogin } 862004e86ffSlogin _ => return Ok(()), 863004e86ffSlogin } 864004e86ffSlogin } 865004e86ffSlogin 866004e86ffSlogin /// @brief 设置文件系统的hard error bit为正常状态 867004e86ffSlogin /// 参考资料:https://thestarman.pcministry.com/DOS/DirtyShutdownFlag.html 868004e86ffSlogin /// 869004e86ffSlogin /// @return Ok(()) 设置成功 870676b8ef6SMork /// @return Err(SystemError) 在设置过程中,出现错误 871676b8ef6SMork pub fn set_hard_error_bit_ok(&mut self) -> Result<(), SystemError> { 872004e86ffSlogin match self.bpb.fat_type { 873004e86ffSlogin FATType::FAT32(_) => { 874004e86ffSlogin let raw_entry = self.get_fat_entry_raw(Cluster::new(1))? | 0x0400_0000; 875004e86ffSlogin self.set_entry(Cluster::new(1), FATEntry::Next(Cluster::new(raw_entry)))?; 876004e86ffSlogin return Ok(()); 877004e86ffSlogin } 878004e86ffSlogin 879004e86ffSlogin FATType::FAT16(_) => { 880004e86ffSlogin let raw_entry = self.get_fat_entry_raw(Cluster::new(1))? | 0x4000; 881004e86ffSlogin self.set_entry(Cluster::new(1), FATEntry::Next(Cluster::new(raw_entry)))?; 882004e86ffSlogin return Ok(()); 883004e86ffSlogin } 884004e86ffSlogin _ => return Ok(()), 885004e86ffSlogin } 886004e86ffSlogin } 887004e86ffSlogin 888004e86ffSlogin /// @brief 执行文件系统卸载前的一些准备工作:设置好对应的标志位,并把缓存中的数据刷入磁盘 889676b8ef6SMork pub fn umount(&mut self) -> Result<(), SystemError> { 890004e86ffSlogin self.fs_info.0.lock().flush(&self.partition)?; 891004e86ffSlogin 892004e86ffSlogin self.set_shut_bit_ok()?; 893004e86ffSlogin 894004e86ffSlogin self.set_hard_error_bit_ok()?; 895004e86ffSlogin 896004e86ffSlogin self.partition.disk().sync()?; 897004e86ffSlogin 898004e86ffSlogin return Ok(()); 899004e86ffSlogin } 900004e86ffSlogin 901004e86ffSlogin /// @brief 获取文件系统的最大簇号 902004e86ffSlogin pub fn max_cluster_number(&self) -> Cluster { 903004e86ffSlogin match self.bpb.fat_type { 904004e86ffSlogin FATType::FAT32(s) => { 905004e86ffSlogin // FAT32 906004e86ffSlogin 907004e86ffSlogin // 数据扇区数量(总扇区数-保留扇区-FAT占用的扇区) 908004e86ffSlogin let data_sec: u64 = self.bpb.total_sectors_32 as u64 909004e86ffSlogin - (self.bpb.rsvd_sec_cnt as u64 910004e86ffSlogin + self.bpb.num_fats as u64 * s.fat_size_32 as u64); 911004e86ffSlogin 912004e86ffSlogin // 数据区的簇数量 913004e86ffSlogin let total_clusters: u64 = data_sec / self.bpb.sector_per_cluster as u64; 914004e86ffSlogin 915004e86ffSlogin // 返回最大的簇号 916004e86ffSlogin return Cluster::new(total_clusters + RESERVED_CLUSTERS as u64 - 1); 917004e86ffSlogin } 918004e86ffSlogin 919004e86ffSlogin _ => { 920004e86ffSlogin // FAT12 / FAT16 921004e86ffSlogin let root_dir_sectors: u64 = (((self.bpb.root_entries_cnt as u64) * 32) 922004e86ffSlogin + self.bpb.bytes_per_sector as u64 923004e86ffSlogin - 1) 924004e86ffSlogin / self.bpb.bytes_per_sector as u64; 925004e86ffSlogin // 数据区扇区数 926004e86ffSlogin let data_sec: u64 = self.bpb.total_sectors_16 as u64 927004e86ffSlogin - (self.bpb.rsvd_sec_cnt as u64 928004e86ffSlogin + (self.bpb.num_fats as u64 * self.bpb.fat_size_16 as u64) 929004e86ffSlogin + root_dir_sectors); 930004e86ffSlogin let total_clusters = data_sec / self.bpb.sector_per_cluster as u64; 931004e86ffSlogin return Cluster::new(total_clusters + RESERVED_CLUSTERS as u64 - 1); 932004e86ffSlogin } 933004e86ffSlogin } 934004e86ffSlogin } 935004e86ffSlogin 936004e86ffSlogin /// @brief 在文件系统中寻找一个簇号在给定的范围(左闭右开区间)内的空闲簇 937004e86ffSlogin /// 938004e86ffSlogin /// @param start_cluster 起始簇号 939004e86ffSlogin /// @param end_cluster 终止簇号(不包含) 940004e86ffSlogin /// 941004e86ffSlogin /// @return Ok(Cluster) 寻找到的空闲簇 942676b8ef6SMork /// @return Err(SystemError) 错误码。如果磁盘无剩余空间,或者簇号达到给定的最大值,则返回-ENOSPC. 943004e86ffSlogin pub fn get_free_cluster( 944004e86ffSlogin &self, 945004e86ffSlogin start_cluster: Cluster, 946004e86ffSlogin end_cluster: Cluster, 947676b8ef6SMork ) -> Result<Cluster, SystemError> { 948004e86ffSlogin let max_cluster: Cluster = self.max_cluster_number(); 949004e86ffSlogin let mut cluster: u64 = start_cluster.cluster_num; 950004e86ffSlogin 951004e86ffSlogin let fat_type: FATType = self.bpb.fat_type; 952004e86ffSlogin let fat_start_sector: u64 = self.fat_start_sector(); 953004e86ffSlogin let bytes_per_sec: u64 = self.bpb.bytes_per_sector as u64; 954004e86ffSlogin 955004e86ffSlogin match fat_type { 956004e86ffSlogin FATType::FAT12(_) => { 957004e86ffSlogin let part_bytes_offset: u64 = 958004e86ffSlogin fat_type.get_fat_bytes_offset(start_cluster, fat_start_sector, bytes_per_sec); 959004e86ffSlogin let in_block_offset = self.get_in_block_offset(part_bytes_offset); 960004e86ffSlogin 961004e86ffSlogin let lba = self.get_lba_from_offset(self.bytes_to_sector(part_bytes_offset)); 962004e86ffSlogin 963004e86ffSlogin // 由于FAT12的FAT表不大于6K,因此直接读取6K 964004e86ffSlogin let num_lba = (6 * 1024) / LBA_SIZE; 965b5b571e0SLoGin let mut v: Vec<u8> = vec![0; num_lba * LBA_SIZE]; 966004e86ffSlogin self.partition.disk().read_at(lba, num_lba, &mut v)?; 967004e86ffSlogin 968004e86ffSlogin let mut cursor: VecCursor = VecCursor::new(v); 969004e86ffSlogin cursor.seek(SeekFrom::SeekSet(in_block_offset as i64))?; 970004e86ffSlogin 971004e86ffSlogin let mut packed_val: u16 = cursor.read_u16()?; 972004e86ffSlogin loop { 973004e86ffSlogin let val = if (cluster & 0x1) > 0 { 974004e86ffSlogin packed_val >> 4 975004e86ffSlogin } else { 976004e86ffSlogin packed_val & 0x0fff 977004e86ffSlogin }; 978004e86ffSlogin if val == 0 { 979b5b571e0SLoGin return Ok(Cluster::new(cluster)); 980004e86ffSlogin } 981004e86ffSlogin 982004e86ffSlogin cluster += 1; 983004e86ffSlogin 984004e86ffSlogin // 磁盘无剩余空间,或者簇号达到给定的最大值 985004e86ffSlogin if cluster == end_cluster.cluster_num || cluster == max_cluster.cluster_num { 986676b8ef6SMork return Err(SystemError::ENOSPC); 987004e86ffSlogin } 988004e86ffSlogin 989004e86ffSlogin packed_val = match cluster & 1 { 990004e86ffSlogin 0 => cursor.read_u16()?, 991004e86ffSlogin _ => { 992004e86ffSlogin let next_byte = cursor.read_u8()? as u16; 993004e86ffSlogin (packed_val >> 8) | (next_byte << 8) 994004e86ffSlogin } 995004e86ffSlogin }; 996004e86ffSlogin } 997004e86ffSlogin } 998004e86ffSlogin FATType::FAT16(_) => { 999004e86ffSlogin // todo: 优化这里,减少读取磁盘的次数。 1000004e86ffSlogin while cluster < end_cluster.cluster_num && cluster < max_cluster.cluster_num { 1001004e86ffSlogin let part_bytes_offset: u64 = fat_type.get_fat_bytes_offset( 1002004e86ffSlogin Cluster::new(cluster), 1003004e86ffSlogin fat_start_sector, 1004004e86ffSlogin bytes_per_sec, 1005004e86ffSlogin ); 1006004e86ffSlogin let in_block_offset = self.get_in_block_offset(part_bytes_offset); 1007004e86ffSlogin 1008004e86ffSlogin let lba = self.get_lba_from_offset(self.bytes_to_sector(part_bytes_offset)); 1009004e86ffSlogin 1010b5b571e0SLoGin let mut v: Vec<u8> = vec![0; self.lba_per_sector() * LBA_SIZE]; 1011004e86ffSlogin self.partition 1012004e86ffSlogin .disk() 1013eb49bb99S曾俊 .read_at_sync(lba, self.lba_per_sector(), &mut v)?; 1014004e86ffSlogin 1015004e86ffSlogin let mut cursor: VecCursor = VecCursor::new(v); 1016004e86ffSlogin cursor.seek(SeekFrom::SeekSet(in_block_offset as i64))?; 1017004e86ffSlogin 1018004e86ffSlogin let val = cursor.read_u16()?; 1019004e86ffSlogin // 找到空闲簇 1020004e86ffSlogin if val == 0 { 1021004e86ffSlogin return Ok(Cluster::new(val as u64)); 1022004e86ffSlogin } 1023004e86ffSlogin cluster += 1; 1024004e86ffSlogin } 1025004e86ffSlogin 1026004e86ffSlogin // 磁盘无剩余空间,或者簇号达到给定的最大值 1027676b8ef6SMork return Err(SystemError::ENOSPC); 1028004e86ffSlogin } 1029004e86ffSlogin FATType::FAT32(_) => { 1030004e86ffSlogin // todo: 优化这里,减少读取磁盘的次数。 1031004e86ffSlogin while cluster < end_cluster.cluster_num && cluster < max_cluster.cluster_num { 1032004e86ffSlogin let part_bytes_offset: u64 = fat_type.get_fat_bytes_offset( 1033004e86ffSlogin Cluster::new(cluster), 1034004e86ffSlogin fat_start_sector, 1035004e86ffSlogin bytes_per_sec, 1036004e86ffSlogin ); 1037004e86ffSlogin let in_block_offset = self.get_in_block_offset(part_bytes_offset); 1038004e86ffSlogin 1039004e86ffSlogin let lba = self.get_lba_from_offset(self.bytes_to_sector(part_bytes_offset)); 1040004e86ffSlogin 1041b5b571e0SLoGin let mut v: Vec<u8> = vec![0; self.lba_per_sector() * LBA_SIZE]; 1042004e86ffSlogin self.partition 1043004e86ffSlogin .disk() 1044eb49bb99S曾俊 .read_at_sync(lba, self.lba_per_sector(), &mut v)?; 1045004e86ffSlogin 1046004e86ffSlogin let mut cursor: VecCursor = VecCursor::new(v); 1047004e86ffSlogin cursor.seek(SeekFrom::SeekSet(in_block_offset as i64))?; 1048004e86ffSlogin 1049004e86ffSlogin let val = cursor.read_u32()? & 0x0fffffff; 1050004e86ffSlogin 1051004e86ffSlogin if val == 0 { 1052004e86ffSlogin return Ok(Cluster::new(cluster)); 1053004e86ffSlogin } 1054004e86ffSlogin cluster += 1; 1055004e86ffSlogin } 1056004e86ffSlogin 1057004e86ffSlogin // 磁盘无剩余空间,或者簇号达到给定的最大值 1058676b8ef6SMork return Err(SystemError::ENOSPC); 1059004e86ffSlogin } 1060004e86ffSlogin } 1061004e86ffSlogin } 1062004e86ffSlogin 1063004e86ffSlogin /// @brief 在FAT表中,设置指定的簇的信息。 1064004e86ffSlogin /// 1065004e86ffSlogin /// @param cluster 目标簇 1066004e86ffSlogin /// @param fat_entry 这个簇在FAT表中,存储的信息(下一个簇的簇号) 1067676b8ef6SMork pub fn set_entry(&self, cluster: Cluster, fat_entry: FATEntry) -> Result<(), SystemError> { 1068004e86ffSlogin // fat表项在分区上的字节偏移量 1069004e86ffSlogin let fat_part_bytes_offset: u64 = self.bpb.fat_type.get_fat_bytes_offset( 1070004e86ffSlogin cluster, 1071004e86ffSlogin self.fat_start_sector(), 1072004e86ffSlogin self.bpb.bytes_per_sector as u64, 1073004e86ffSlogin ); 1074004e86ffSlogin 1075004e86ffSlogin match self.bpb.fat_type { 1076004e86ffSlogin FATType::FAT12(_) => { 1077004e86ffSlogin // 计算要写入的值 1078004e86ffSlogin let raw_val: u16 = match fat_entry { 1079004e86ffSlogin FATEntry::Unused => 0, 1080004e86ffSlogin FATEntry::Bad => 0xff7, 1081004e86ffSlogin FATEntry::EndOfChain => 0xfff, 1082004e86ffSlogin FATEntry::Next(c) => c.cluster_num as u16, 1083004e86ffSlogin }; 1084004e86ffSlogin 1085004e86ffSlogin let in_block_offset = self.get_in_block_offset(fat_part_bytes_offset); 1086004e86ffSlogin 1087004e86ffSlogin let lba = self.get_lba_from_offset(self.bytes_to_sector(fat_part_bytes_offset)); 1088004e86ffSlogin 1089b5b571e0SLoGin let mut v: Vec<u8> = vec![0; LBA_SIZE]; 1090eb49bb99S曾俊 self.partition.disk().read_at_sync(lba, 1, &mut v)?; 1091004e86ffSlogin 1092004e86ffSlogin let mut cursor: VecCursor = VecCursor::new(v); 1093004e86ffSlogin cursor.seek(SeekFrom::SeekSet(in_block_offset as i64))?; 1094004e86ffSlogin 1095004e86ffSlogin let old_val: u16 = cursor.read_u16()?; 1096004e86ffSlogin let new_val: u16 = if (cluster.cluster_num & 0x1) > 0 { 1097004e86ffSlogin (old_val & 0x000f) | (raw_val << 4) 1098004e86ffSlogin } else { 1099004e86ffSlogin (old_val & 0xf000) | raw_val 1100004e86ffSlogin }; 1101004e86ffSlogin 1102004e86ffSlogin // 写回数据到磁盘上 1103004e86ffSlogin cursor.seek(SeekFrom::SeekSet(in_block_offset as i64))?; 1104004e86ffSlogin cursor.write_u16(new_val)?; 1105004e86ffSlogin self.partition.disk().write_at(lba, 1, cursor.as_slice())?; 1106004e86ffSlogin return Ok(()); 1107004e86ffSlogin } 1108004e86ffSlogin FATType::FAT16(_) => { 1109004e86ffSlogin // 计算要写入的值 1110004e86ffSlogin let raw_val: u16 = match fat_entry { 1111004e86ffSlogin FATEntry::Unused => 0, 1112004e86ffSlogin FATEntry::Bad => 0xfff7, 1113004e86ffSlogin FATEntry::EndOfChain => 0xfdff, 1114004e86ffSlogin FATEntry::Next(c) => c.cluster_num as u16, 1115004e86ffSlogin }; 1116004e86ffSlogin 1117004e86ffSlogin let in_block_offset = self.get_in_block_offset(fat_part_bytes_offset); 1118004e86ffSlogin 1119004e86ffSlogin let lba = self.get_lba_from_offset(self.bytes_to_sector(fat_part_bytes_offset)); 1120004e86ffSlogin 1121b5b571e0SLoGin let mut v: Vec<u8> = vec![0; LBA_SIZE]; 1122004e86ffSlogin self.partition.disk().read_at(lba, 1, &mut v)?; 1123004e86ffSlogin 1124004e86ffSlogin let mut cursor: VecCursor = VecCursor::new(v); 1125004e86ffSlogin cursor.seek(SeekFrom::SeekSet(in_block_offset as i64))?; 1126004e86ffSlogin 1127004e86ffSlogin cursor.write_u16(raw_val)?; 1128004e86ffSlogin self.partition.disk().write_at(lba, 1, cursor.as_slice())?; 1129004e86ffSlogin 1130004e86ffSlogin return Ok(()); 1131004e86ffSlogin } 1132004e86ffSlogin FATType::FAT32(_) => { 1133004e86ffSlogin let fat_size: u64 = self.fat_size(); 1134004e86ffSlogin let bound: u64 = if self.mirroring_enabled() { 1135004e86ffSlogin 1 1136004e86ffSlogin } else { 1137004e86ffSlogin self.bpb.num_fats as u64 1138004e86ffSlogin }; 11392eab6dd7S曾俊 // debug!("set entry, bound={bound}, fat_size={fat_size}"); 1140004e86ffSlogin for i in 0..bound { 1141004e86ffSlogin // 当前操作的FAT表在磁盘上的字节偏移量 1142004e86ffSlogin let f_offset: u64 = fat_part_bytes_offset + i * fat_size; 1143004e86ffSlogin let in_block_offset: u64 = self.get_in_block_offset(f_offset); 1144004e86ffSlogin let lba = self.get_lba_from_offset(self.bytes_to_sector(f_offset)); 1145004e86ffSlogin 11462eab6dd7S曾俊 // debug!("set entry, lba={lba}, in_block_offset={in_block_offset}"); 1147b5b571e0SLoGin let mut v: Vec<u8> = vec![0; LBA_SIZE]; 1148004e86ffSlogin self.partition.disk().read_at(lba, 1, &mut v)?; 1149004e86ffSlogin 1150004e86ffSlogin let mut cursor: VecCursor = VecCursor::new(v); 1151004e86ffSlogin cursor.seek(SeekFrom::SeekSet(in_block_offset as i64))?; 1152004e86ffSlogin 1153004e86ffSlogin // FAT32的高4位保留 1154004e86ffSlogin let old_bits = cursor.read_u32()? & 0xf0000000; 1155004e86ffSlogin 1156004e86ffSlogin if fat_entry == FATEntry::Unused 1157004e86ffSlogin && cluster.cluster_num >= 0x0ffffff7 1158004e86ffSlogin && cluster.cluster_num <= 0x0fffffff 1159004e86ffSlogin { 11602eab6dd7S曾俊 error!( 1161004e86ffSlogin "FAT32: Reserved Cluster {:?} cannot be marked as free", 1162004e86ffSlogin cluster 1163004e86ffSlogin ); 1164676b8ef6SMork return Err(SystemError::EPERM); 1165004e86ffSlogin } 1166004e86ffSlogin 1167004e86ffSlogin // 计算要写入的值 1168004e86ffSlogin let mut raw_val: u32 = match fat_entry { 1169004e86ffSlogin FATEntry::Unused => 0, 1170004e86ffSlogin FATEntry::Bad => 0x0FFFFFF7, 1171004e86ffSlogin FATEntry::EndOfChain => 0x0FFFFFFF, 1172004e86ffSlogin FATEntry::Next(c) => c.cluster_num as u32, 1173004e86ffSlogin }; 1174004e86ffSlogin 1175004e86ffSlogin // 恢复保留位 1176004e86ffSlogin raw_val |= old_bits; 1177004e86ffSlogin 11782eab6dd7S曾俊 // debug!("sent entry, raw_val={raw_val}"); 1179004e86ffSlogin 1180004e86ffSlogin cursor.seek(SeekFrom::SeekSet(in_block_offset as i64))?; 1181004e86ffSlogin cursor.write_u32(raw_val)?; 1182004e86ffSlogin 1183004e86ffSlogin self.partition.disk().write_at(lba, 1, cursor.as_slice())?; 1184004e86ffSlogin } 1185004e86ffSlogin 1186004e86ffSlogin return Ok(()); 1187004e86ffSlogin } 1188004e86ffSlogin } 1189004e86ffSlogin } 1190004e86ffSlogin 1191004e86ffSlogin /// @brief 清空指定的簇 1192004e86ffSlogin /// 1193004e86ffSlogin /// @param cluster 要被清空的簇 1194676b8ef6SMork pub fn zero_cluster(&self, cluster: Cluster) -> Result<(), SystemError> { 1195004e86ffSlogin // 准备数据,用于写入 1196004e86ffSlogin let zeros: Vec<u8> = vec![0u8; self.bytes_per_cluster() as usize]; 1197004e86ffSlogin let offset: usize = self.cluster_bytes_offset(cluster) as usize; 1198004e86ffSlogin self.partition 1199004e86ffSlogin .disk() 1200b087521eSChiichen .write_at_bytes(offset, zeros.len(), zeros.as_slice())?; 1201004e86ffSlogin return Ok(()); 1202004e86ffSlogin } 1203004e86ffSlogin } 1204004e86ffSlogin 1205004e86ffSlogin impl Drop for FATFileSystem { 1206004e86ffSlogin fn drop(&mut self) { 1207004e86ffSlogin let r = self.umount(); 1208004e86ffSlogin if r.is_err() { 12092eab6dd7S曾俊 error!( 1210676b8ef6SMork "Umount FAT filesystem failed: errno={:?}, FS detail:{self:?}", 12118d72b68dSJomo r.as_ref().unwrap_err() 1212004e86ffSlogin ); 1213004e86ffSlogin } 1214004e86ffSlogin } 1215004e86ffSlogin } 1216004e86ffSlogin 1217004e86ffSlogin impl FATFsInfo { 1218004e86ffSlogin const LEAD_SIG: u32 = 0x41615252; 1219004e86ffSlogin const STRUC_SIG: u32 = 0x61417272; 1220004e86ffSlogin const TRAIL_SIG: u32 = 0xAA550000; 122191e9d4abSLoGin #[allow(dead_code)] 1222004e86ffSlogin const FS_INFO_SIZE: u64 = 512; 1223004e86ffSlogin 1224004e86ffSlogin /// @brief 从磁盘上读取FAT文件系统的FSInfo结构体 1225004e86ffSlogin /// 1226004e86ffSlogin /// @param partition 磁盘分区 1227004e86ffSlogin /// @param in_disk_fs_info_offset FSInfo扇区在磁盘内的字节偏移量(单位:字节) 1228004e86ffSlogin /// @param bytes_per_sec 每扇区字节数 1229004e86ffSlogin pub fn new( 1230004e86ffSlogin partition: Arc<Partition>, 1231004e86ffSlogin in_disk_fs_info_offset: u64, 1232004e86ffSlogin bytes_per_sec: usize, 1233676b8ef6SMork ) -> Result<Self, SystemError> { 1234b5b571e0SLoGin let mut v = vec![0; bytes_per_sec]; 1235004e86ffSlogin 1236004e86ffSlogin // 计算fs_info扇区在磁盘上的字节偏移量,从磁盘读取数据 1237004e86ffSlogin partition 1238004e86ffSlogin .disk() 1239eb49bb99S曾俊 .read_at_sync(in_disk_fs_info_offset as usize / LBA_SIZE, 1, &mut v)?; 1240004e86ffSlogin let mut cursor = VecCursor::new(v); 1241004e86ffSlogin 1242b5b571e0SLoGin let mut fsinfo = FATFsInfo { 1243b5b571e0SLoGin lead_sig: cursor.read_u32()?, 1244b5b571e0SLoGin ..Default::default() 1245b5b571e0SLoGin }; 1246004e86ffSlogin cursor.seek(SeekFrom::SeekCurrent(480))?; 1247004e86ffSlogin fsinfo.struc_sig = cursor.read_u32()?; 1248004e86ffSlogin fsinfo.free_count = cursor.read_u32()?; 1249004e86ffSlogin fsinfo.next_free = cursor.read_u32()?; 1250004e86ffSlogin 1251004e86ffSlogin cursor.seek(SeekFrom::SeekCurrent(12))?; 1252004e86ffSlogin 1253004e86ffSlogin fsinfo.trail_sig = cursor.read_u32()?; 1254004e86ffSlogin fsinfo.dirty = false; 1255004e86ffSlogin fsinfo.offset = Some(in_disk_fs_info_offset); 1256004e86ffSlogin 1257004e86ffSlogin if fsinfo.is_valid() { 1258004e86ffSlogin return Ok(fsinfo); 1259004e86ffSlogin } else { 12602eab6dd7S曾俊 error!("Error occurred while parsing FATFsInfo."); 1261676b8ef6SMork return Err(SystemError::EINVAL); 1262004e86ffSlogin } 1263004e86ffSlogin } 1264004e86ffSlogin 1265004e86ffSlogin /// @brief 判断是否为正确的FsInfo结构体 1266004e86ffSlogin fn is_valid(&self) -> bool { 1267004e86ffSlogin self.lead_sig == Self::LEAD_SIG 1268004e86ffSlogin && self.struc_sig == Self::STRUC_SIG 1269004e86ffSlogin && self.trail_sig == Self::TRAIL_SIG 1270004e86ffSlogin } 1271004e86ffSlogin 1272004e86ffSlogin /// @brief 根据fsinfo的信息,计算当前总的空闲簇数量 1273004e86ffSlogin /// 1274004e86ffSlogin /// @param 当前文件系统的最大簇号 1275004e86ffSlogin pub fn count_free_cluster(&self, max_cluster: Cluster) -> Option<u64> { 1276004e86ffSlogin let count_clusters = max_cluster.cluster_num - RESERVED_CLUSTERS as u64 + 1; 1277004e86ffSlogin // 信息不合理,当前的FsInfo中存储的free count大于计算出来的值 1278004e86ffSlogin if self.free_count as u64 > count_clusters { 1279004e86ffSlogin return None; 1280004e86ffSlogin } else { 1281004e86ffSlogin match self.free_count { 1282004e86ffSlogin // free count字段不可用 1283004e86ffSlogin 0xffffffff => return None, 1284004e86ffSlogin // 返回FsInfo中存储的数据 1285004e86ffSlogin n => return Some(n as u64), 1286004e86ffSlogin } 1287004e86ffSlogin } 1288004e86ffSlogin } 1289004e86ffSlogin 1290004e86ffSlogin /// @brief 更新FsInfo中的“空闲簇统计信息“为new_count 1291004e86ffSlogin /// 1292004e86ffSlogin /// 请注意,除非手动调用`flush()`,否则本函数不会将数据刷入磁盘 1293004e86ffSlogin pub fn update_free_count_abs(&mut self, new_count: u32) { 1294004e86ffSlogin self.free_count = new_count; 1295004e86ffSlogin } 1296004e86ffSlogin 1297004e86ffSlogin /// @brief 更新FsInfo中的“空闲簇统计信息“,把它加上delta. 1298004e86ffSlogin /// 1299004e86ffSlogin /// 请注意,除非手动调用`flush()`,否则本函数不会将数据刷入磁盘 1300004e86ffSlogin pub fn update_free_count_delta(&mut self, delta: i32) { 1301004e86ffSlogin self.free_count = (self.free_count as i32 + delta) as u32; 1302004e86ffSlogin } 1303004e86ffSlogin 1304004e86ffSlogin /// @brief 更新FsInfo中的“第一个空闲簇统计信息“为next_free. 1305004e86ffSlogin /// 1306004e86ffSlogin /// 请注意,除非手动调用`flush()`,否则本函数不会将数据刷入磁盘 1307004e86ffSlogin pub fn update_next_free(&mut self, next_free: u32) { 1308004e86ffSlogin // 这个值是参考量,不一定要准确,仅供加速查找 1309004e86ffSlogin self.next_free = next_free; 1310004e86ffSlogin } 1311004e86ffSlogin 1312004e86ffSlogin /// @brief 获取fs info 记载的第一个空闲簇。(不一定准确,仅供参考) 1313004e86ffSlogin pub fn next_free(&self) -> Option<u64> { 1314004e86ffSlogin match self.next_free { 1315004e86ffSlogin 0xffffffff => return None, 1316004e86ffSlogin 0 | 1 => return None, 1317004e86ffSlogin n => return Some(n as u64), 1318004e86ffSlogin }; 1319004e86ffSlogin } 1320004e86ffSlogin 1321004e86ffSlogin /// @brief 把fs info刷入磁盘 1322004e86ffSlogin /// 1323004e86ffSlogin /// @param partition fs info所在的分区 1324676b8ef6SMork pub fn flush(&self, partition: &Arc<Partition>) -> Result<(), SystemError> { 1325004e86ffSlogin if let Some(off) = self.offset { 1326004e86ffSlogin let in_block_offset = off % LBA_SIZE as u64; 1327004e86ffSlogin 1328004e86ffSlogin let lba = off as usize / LBA_SIZE; 1329004e86ffSlogin 1330b5b571e0SLoGin let mut v: Vec<u8> = vec![0; LBA_SIZE]; 1331004e86ffSlogin partition.disk().read_at(lba, 1, &mut v)?; 1332004e86ffSlogin 1333004e86ffSlogin let mut cursor: VecCursor = VecCursor::new(v); 1334004e86ffSlogin cursor.seek(SeekFrom::SeekSet(in_block_offset as i64))?; 1335004e86ffSlogin 1336004e86ffSlogin cursor.write_u32(self.lead_sig)?; 1337004e86ffSlogin cursor.seek(SeekFrom::SeekCurrent(480))?; 1338004e86ffSlogin cursor.write_u32(self.struc_sig)?; 1339004e86ffSlogin cursor.write_u32(self.free_count)?; 1340004e86ffSlogin cursor.write_u32(self.next_free)?; 1341004e86ffSlogin cursor.seek(SeekFrom::SeekCurrent(12))?; 1342004e86ffSlogin cursor.write_u32(self.trail_sig)?; 1343004e86ffSlogin 1344004e86ffSlogin partition.disk().write_at(lba, 1, cursor.as_slice())?; 1345004e86ffSlogin } 1346004e86ffSlogin return Ok(()); 1347004e86ffSlogin } 1348004e86ffSlogin 1349004e86ffSlogin /// @brief 读取磁盘上的Fs Info扇区,将里面的内容更新到结构体中 1350004e86ffSlogin /// 1351004e86ffSlogin /// @param partition fs info所在的分区 1352676b8ef6SMork pub fn update(&mut self, partition: Arc<Partition>) -> Result<(), SystemError> { 1353004e86ffSlogin if let Some(off) = self.offset { 1354004e86ffSlogin let in_block_offset = off % LBA_SIZE as u64; 1355004e86ffSlogin 1356004e86ffSlogin let lba = off as usize / LBA_SIZE; 1357004e86ffSlogin 1358b5b571e0SLoGin let mut v: Vec<u8> = vec![0; LBA_SIZE]; 1359004e86ffSlogin partition.disk().read_at(lba, 1, &mut v)?; 1360004e86ffSlogin let mut cursor: VecCursor = VecCursor::new(v); 1361004e86ffSlogin cursor.seek(SeekFrom::SeekSet(in_block_offset as i64))?; 1362004e86ffSlogin self.lead_sig = cursor.read_u32()?; 1363004e86ffSlogin 1364004e86ffSlogin cursor.seek(SeekFrom::SeekCurrent(480))?; 1365004e86ffSlogin self.struc_sig = cursor.read_u32()?; 1366004e86ffSlogin self.free_count = cursor.read_u32()?; 1367004e86ffSlogin self.next_free = cursor.read_u32()?; 1368004e86ffSlogin cursor.seek(SeekFrom::SeekCurrent(12))?; 1369004e86ffSlogin self.trail_sig = cursor.read_u32()?; 1370004e86ffSlogin } 1371004e86ffSlogin return Ok(()); 1372004e86ffSlogin } 1373004e86ffSlogin } 1374004e86ffSlogin 1375004e86ffSlogin impl IndexNode for LockedFATInode { 1376004e86ffSlogin fn read_at( 1377004e86ffSlogin &self, 1378004e86ffSlogin offset: usize, 1379004e86ffSlogin len: usize, 1380004e86ffSlogin buf: &mut [u8], 1381dfe53cf0SGnoCiYeH _data: SpinLockGuard<FilePrivateData>, 1382676b8ef6SMork ) -> Result<usize, SystemError> { 1383004e86ffSlogin let mut guard: SpinLockGuard<FATInode> = self.0.lock(); 1384004e86ffSlogin match &guard.inode_type { 1385004e86ffSlogin FATDirEntry::File(f) | FATDirEntry::VolId(f) => { 1386004e86ffSlogin let r = f.read( 1387004e86ffSlogin &guard.fs.upgrade().unwrap(), 1388004e86ffSlogin &mut buf[0..len], 1389004e86ffSlogin offset as u64, 1390004e86ffSlogin ); 1391004e86ffSlogin guard.update_metadata(); 1392004e86ffSlogin return r; 1393004e86ffSlogin } 1394004e86ffSlogin FATDirEntry::Dir(_) => { 1395676b8ef6SMork return Err(SystemError::EISDIR); 1396004e86ffSlogin } 1397004e86ffSlogin FATDirEntry::UnInit => { 13982eab6dd7S曾俊 error!("FATFS: param: Inode_type uninitialized."); 1399676b8ef6SMork return Err(SystemError::EROFS); 1400004e86ffSlogin } 1401004e86ffSlogin } 1402004e86ffSlogin } 1403004e86ffSlogin 1404004e86ffSlogin fn write_at( 1405004e86ffSlogin &self, 1406004e86ffSlogin offset: usize, 1407004e86ffSlogin len: usize, 1408004e86ffSlogin buf: &[u8], 1409dfe53cf0SGnoCiYeH _data: SpinLockGuard<FilePrivateData>, 1410676b8ef6SMork ) -> Result<usize, SystemError> { 1411004e86ffSlogin let mut guard: SpinLockGuard<FATInode> = self.0.lock(); 1412004e86ffSlogin let fs: &Arc<FATFileSystem> = &guard.fs.upgrade().unwrap(); 1413004e86ffSlogin 1414004e86ffSlogin match &mut guard.inode_type { 1415004e86ffSlogin FATDirEntry::File(f) | FATDirEntry::VolId(f) => { 1416004e86ffSlogin let r = f.write(fs, &buf[0..len], offset as u64); 1417004e86ffSlogin guard.update_metadata(); 1418004e86ffSlogin return r; 1419004e86ffSlogin } 1420004e86ffSlogin FATDirEntry::Dir(_) => { 1421676b8ef6SMork return Err(SystemError::EISDIR); 1422004e86ffSlogin } 1423004e86ffSlogin FATDirEntry::UnInit => { 14242eab6dd7S曾俊 error!("FATFS: param: Inode_type uninitialized."); 1425676b8ef6SMork return Err(SystemError::EROFS); 1426004e86ffSlogin } 1427004e86ffSlogin } 1428004e86ffSlogin } 1429004e86ffSlogin 1430004e86ffSlogin fn create( 1431004e86ffSlogin &self, 1432004e86ffSlogin name: &str, 1433004e86ffSlogin file_type: FileType, 14346b4e7a29SLoGin _mode: ModeType, 1435676b8ef6SMork ) -> Result<Arc<dyn IndexNode>, SystemError> { 1436004e86ffSlogin // 由于FAT32不支持文件权限的功能,因此忽略mode参数 1437004e86ffSlogin let mut guard: SpinLockGuard<FATInode> = self.0.lock(); 1438004e86ffSlogin let fs: &Arc<FATFileSystem> = &guard.fs.upgrade().unwrap(); 1439004e86ffSlogin 1440004e86ffSlogin match &mut guard.inode_type { 1441004e86ffSlogin FATDirEntry::File(_) | FATDirEntry::VolId(_) => { 1442676b8ef6SMork return Err(SystemError::ENOTDIR); 1443004e86ffSlogin } 1444004e86ffSlogin FATDirEntry::Dir(d) => match file_type { 1445004e86ffSlogin FileType::File => { 1446004e86ffSlogin d.create_file(name, fs)?; 1447004e86ffSlogin return Ok(guard.find(name)?); 1448004e86ffSlogin } 1449004e86ffSlogin FileType::Dir => { 1450004e86ffSlogin d.create_dir(name, fs)?; 1451004e86ffSlogin return Ok(guard.find(name)?); 1452004e86ffSlogin } 1453004e86ffSlogin 14541074eb34SSamuel Dai FileType::SymLink => return Err(SystemError::ENOSYS), 1455676b8ef6SMork _ => return Err(SystemError::EINVAL), 1456004e86ffSlogin }, 1457004e86ffSlogin FATDirEntry::UnInit => { 14582eab6dd7S曾俊 error!("FATFS: param: Inode_type uninitialized."); 1459676b8ef6SMork return Err(SystemError::EROFS); 1460004e86ffSlogin } 1461004e86ffSlogin } 1462004e86ffSlogin } 1463004e86ffSlogin 1464004e86ffSlogin fn fs(&self) -> Arc<dyn FileSystem> { 1465004e86ffSlogin return self.0.lock().fs.upgrade().unwrap(); 1466004e86ffSlogin } 1467004e86ffSlogin 1468004e86ffSlogin fn as_any_ref(&self) -> &dyn core::any::Any { 1469004e86ffSlogin return self; 1470004e86ffSlogin } 1471004e86ffSlogin 1472676b8ef6SMork fn metadata(&self) -> Result<Metadata, SystemError> { 1473004e86ffSlogin return Ok(self.0.lock().metadata.clone()); 1474004e86ffSlogin } 1475*6f189d27Slinfeng fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> { 1476*6f189d27Slinfeng let inode = &mut self.0.lock(); 1477*6f189d27Slinfeng inode.metadata.atime = metadata.atime; 1478*6f189d27Slinfeng inode.metadata.mtime = metadata.mtime; 1479*6f189d27Slinfeng inode.metadata.ctime = metadata.ctime; 1480*6f189d27Slinfeng inode.metadata.mode = metadata.mode; 1481*6f189d27Slinfeng inode.metadata.uid = metadata.uid; 1482*6f189d27Slinfeng inode.metadata.gid = metadata.gid; 1483*6f189d27Slinfeng Ok(()) 1484*6f189d27Slinfeng } 14856d81180bSLoGin fn resize(&self, len: usize) -> Result<(), SystemError> { 14866d81180bSLoGin let mut guard: SpinLockGuard<FATInode> = self.0.lock(); 14876d81180bSLoGin let fs: &Arc<FATFileSystem> = &guard.fs.upgrade().unwrap(); 14886d81180bSLoGin let old_size = guard.metadata.size as usize; 14896d81180bSLoGin 14906d81180bSLoGin match &mut guard.inode_type { 14916d81180bSLoGin FATDirEntry::File(file) | FATDirEntry::VolId(file) => { 14926d81180bSLoGin // 如果新的长度和旧的长度相同,那么就直接返回 1493b5b571e0SLoGin match len.cmp(&old_size) { 1494b5b571e0SLoGin Ordering::Equal => { 14956d81180bSLoGin return Ok(()); 1496b5b571e0SLoGin } 1497b5b571e0SLoGin Ordering::Greater => { 14986d81180bSLoGin // 如果新的长度比旧的长度大,那么就在文件末尾添加空白 14996d81180bSLoGin let mut buf: Vec<u8> = Vec::new(); 15006d81180bSLoGin let mut remain_size = len - old_size; 15016d81180bSLoGin let buf_size = remain_size; 15026d81180bSLoGin // let buf_size = core::cmp::min(remain_size, 512 * 1024); 15036d81180bSLoGin buf.resize(buf_size, 0); 15046d81180bSLoGin 15056d81180bSLoGin let mut offset = old_size; 15066d81180bSLoGin while remain_size > 0 { 15076d81180bSLoGin let write_size = core::cmp::min(remain_size, buf_size); 15086d81180bSLoGin file.write(fs, &buf[0..write_size], offset as u64)?; 15096d81180bSLoGin remain_size -= write_size; 15106d81180bSLoGin offset += write_size; 15116d81180bSLoGin } 1512b5b571e0SLoGin } 1513b5b571e0SLoGin Ordering::Less => { 15146d81180bSLoGin file.truncate(fs, len as u64)?; 15156d81180bSLoGin } 1516b5b571e0SLoGin } 15176d81180bSLoGin guard.update_metadata(); 15186d81180bSLoGin return Ok(()); 15196d81180bSLoGin } 15201074eb34SSamuel Dai FATDirEntry::Dir(_) => return Err(SystemError::ENOSYS), 15216d81180bSLoGin FATDirEntry::UnInit => { 15222eab6dd7S曾俊 error!("FATFS: param: Inode_type uninitialized."); 15236d81180bSLoGin return Err(SystemError::EROFS); 15246d81180bSLoGin } 15256d81180bSLoGin } 15266d81180bSLoGin } 1527004e86ffSlogin 152804babc3fSMemoryShore fn truncate(&self, len: usize) -> Result<(), SystemError> { 152904babc3fSMemoryShore let guard: SpinLockGuard<FATInode> = self.0.lock(); 153004babc3fSMemoryShore let old_size = guard.metadata.size as usize; 153104babc3fSMemoryShore if len < old_size { 153204babc3fSMemoryShore drop(guard); 153304babc3fSMemoryShore self.resize(len) 153404babc3fSMemoryShore } else { 153504babc3fSMemoryShore Ok(()) 153604babc3fSMemoryShore } 153704babc3fSMemoryShore } 153804babc3fSMemoryShore 1539676b8ef6SMork fn list(&self) -> Result<Vec<String>, SystemError> { 1540004e86ffSlogin let mut guard: SpinLockGuard<FATInode> = self.0.lock(); 1541004e86ffSlogin let fatent: &FATDirEntry = &guard.inode_type; 1542004e86ffSlogin match fatent { 1543004e86ffSlogin FATDirEntry::File(_) | FATDirEntry::VolId(_) => { 1544676b8ef6SMork return Err(SystemError::ENOTDIR); 1545004e86ffSlogin } 1546004e86ffSlogin FATDirEntry::Dir(dir) => { 1547004e86ffSlogin // 获取当前目录下的所有目录项 1548004e86ffSlogin let mut ret: Vec<String> = Vec::new(); 1549004e86ffSlogin let dir_iter: FATDirIter = dir.to_iter(guard.fs.upgrade().unwrap()); 1550004e86ffSlogin for ent in dir_iter { 1551004e86ffSlogin ret.push(ent.name()); 1552004e86ffSlogin 1553004e86ffSlogin // ====== 生成inode缓存,存入B树 15541074eb34SSamuel Dai let name = DName::from(ent.name().to_uppercase()); 15552eab6dd7S曾俊 // debug!("name={name}"); 1556004e86ffSlogin 15571074eb34SSamuel Dai if !guard.children.contains_key(&name) 15581074eb34SSamuel Dai && name.as_ref() != "." 15591074eb34SSamuel Dai && name.as_ref() != ".." 1560004e86ffSlogin { 1561004e86ffSlogin // 创建新的inode 1562004e86ffSlogin let entry_inode: Arc<LockedFATInode> = LockedFATInode::new( 15631074eb34SSamuel Dai name.clone(), 1564004e86ffSlogin guard.fs.upgrade().unwrap(), 1565004e86ffSlogin guard.self_ref.clone(), 1566004e86ffSlogin ent, 1567004e86ffSlogin ); 1568004e86ffSlogin // 加入缓存区, 由于FAT文件系统的大小写不敏感问题,因此存入缓存区的key应当是全大写的 15691074eb34SSamuel Dai guard.children.insert(name, entry_inode.clone()); 1570004e86ffSlogin } 1571004e86ffSlogin } 1572004e86ffSlogin return Ok(ret); 1573004e86ffSlogin } 1574004e86ffSlogin FATDirEntry::UnInit => { 15752eab6dd7S曾俊 error!("FATFS: param: Inode_type uninitialized."); 1576676b8ef6SMork return Err(SystemError::EROFS); 1577004e86ffSlogin } 1578004e86ffSlogin } 1579004e86ffSlogin } 1580004e86ffSlogin 1581676b8ef6SMork fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, SystemError> { 1582004e86ffSlogin let mut guard: SpinLockGuard<FATInode> = self.0.lock(); 1583004e86ffSlogin let target = guard.find(name)?; 1584004e86ffSlogin return Ok(target); 1585004e86ffSlogin } 1586004e86ffSlogin 1587dfe53cf0SGnoCiYeH fn open( 1588dfe53cf0SGnoCiYeH &self, 1589dfe53cf0SGnoCiYeH _data: SpinLockGuard<FilePrivateData>, 1590dfe53cf0SGnoCiYeH _mode: &FileMode, 1591dfe53cf0SGnoCiYeH ) -> Result<(), SystemError> { 1592004e86ffSlogin return Ok(()); 1593004e86ffSlogin } 1594004e86ffSlogin 1595dfe53cf0SGnoCiYeH fn close(&self, _data: SpinLockGuard<FilePrivateData>) -> Result<(), SystemError> { 1596004e86ffSlogin return Ok(()); 1597004e86ffSlogin } 1598004e86ffSlogin 1599676b8ef6SMork fn unlink(&self, name: &str) -> Result<(), SystemError> { 1600004e86ffSlogin let mut guard: SpinLockGuard<FATInode> = self.0.lock(); 1601004e86ffSlogin let target: Arc<LockedFATInode> = guard.find(name)?; 1602004e86ffSlogin // 对目标inode上锁,以防更改 1603004e86ffSlogin let target_guard: SpinLockGuard<FATInode> = target.0.lock(); 1604004e86ffSlogin // 先从缓存删除 16051074eb34SSamuel Dai let nod = guard.children.remove(&DName::from(name.to_uppercase())); 16062dbef785SGnoCiYeH 16072dbef785SGnoCiYeH // 若删除缓存中为管道的文件,则不需要再到磁盘删除 1608b5b571e0SLoGin if nod.is_some() { 16092dbef785SGnoCiYeH let file_type = target_guard.metadata.file_type; 16102dbef785SGnoCiYeH if file_type == FileType::Pipe { 16112dbef785SGnoCiYeH return Ok(()); 16122dbef785SGnoCiYeH } 16132dbef785SGnoCiYeH } 1614004e86ffSlogin 1615004e86ffSlogin let dir = match &guard.inode_type { 1616004e86ffSlogin FATDirEntry::File(_) | FATDirEntry::VolId(_) => { 1617676b8ef6SMork return Err(SystemError::ENOTDIR); 1618004e86ffSlogin } 1619004e86ffSlogin FATDirEntry::Dir(d) => d, 1620004e86ffSlogin FATDirEntry::UnInit => { 16212eab6dd7S曾俊 error!("FATFS: param: Inode_type uninitialized."); 1622676b8ef6SMork return Err(SystemError::EROFS); 1623004e86ffSlogin } 1624004e86ffSlogin }; 1625004e86ffSlogin // 检查文件是否存在 1626004e86ffSlogin dir.check_existence(name, Some(false), guard.fs.upgrade().unwrap())?; 1627004e86ffSlogin 1628004e86ffSlogin // 再从磁盘删除 1629004e86ffSlogin let r = dir.remove(guard.fs.upgrade().unwrap().clone(), name, true); 1630004e86ffSlogin drop(target_guard); 1631004e86ffSlogin return r; 1632004e86ffSlogin } 1633004e86ffSlogin 1634676b8ef6SMork fn rmdir(&self, name: &str) -> Result<(), SystemError> { 1635004e86ffSlogin let mut guard: SpinLockGuard<FATInode> = self.0.lock(); 1636004e86ffSlogin let target: Arc<LockedFATInode> = guard.find(name)?; 1637004e86ffSlogin // 对目标inode上锁,以防更改 1638004e86ffSlogin let target_guard: SpinLockGuard<FATInode> = target.0.lock(); 1639004e86ffSlogin // 先从缓存删除 16401074eb34SSamuel Dai guard.children.remove(&DName::from(name.to_uppercase())); 1641004e86ffSlogin 1642004e86ffSlogin let dir = match &guard.inode_type { 1643004e86ffSlogin FATDirEntry::File(_) | FATDirEntry::VolId(_) => { 1644676b8ef6SMork return Err(SystemError::ENOTDIR); 1645004e86ffSlogin } 1646004e86ffSlogin FATDirEntry::Dir(d) => d, 1647004e86ffSlogin FATDirEntry::UnInit => { 16482eab6dd7S曾俊 error!("FATFS: param: Inode_type uninitialized."); 1649676b8ef6SMork return Err(SystemError::EROFS); 1650004e86ffSlogin } 1651004e86ffSlogin }; 1652004e86ffSlogin // 检查文件夹是否存在 1653004e86ffSlogin dir.check_existence(name, Some(true), guard.fs.upgrade().unwrap())?; 1654004e86ffSlogin 1655004e86ffSlogin // 再从磁盘删除 165678bf93f0SYJwu2023 let r: Result<(), SystemError> = 165778bf93f0SYJwu2023 dir.remove(guard.fs.upgrade().unwrap().clone(), name, true); 1658b5b571e0SLoGin match r { 1659b5b571e0SLoGin Ok(_) => return r, 1660b5b571e0SLoGin Err(r) => { 1661676b8ef6SMork if r == SystemError::ENOTEMPTY { 1662004e86ffSlogin // 如果要删除的是目录,且不为空,则删除动作未发生,重新加入缓存 16631074eb34SSamuel Dai guard 16641074eb34SSamuel Dai .children 16651074eb34SSamuel Dai .insert(DName::from(name.to_uppercase()), target.clone()); 1666004e86ffSlogin drop(target_guard); 1667004e86ffSlogin } 1668004e86ffSlogin return Err(r); 1669004e86ffSlogin } 1670004e86ffSlogin } 1671b5b571e0SLoGin } 1672004e86ffSlogin 16739e481b3bSTTaq fn move_to( 16749e481b3bSTTaq &self, 16759e481b3bSTTaq old_name: &str, 16769e481b3bSTTaq target: &Arc<dyn IndexNode>, 16779e481b3bSTTaq new_name: &str, 16789e481b3bSTTaq ) -> Result<(), SystemError> { 16799e481b3bSTTaq let old_id = self.metadata().unwrap().inode_id; 16809e481b3bSTTaq let new_id = target.metadata().unwrap().inode_id; 16819e481b3bSTTaq // 若在同一父目录下 16829e481b3bSTTaq if old_id == new_id { 16839e481b3bSTTaq let mut guard = self.0.lock(); 16849e481b3bSTTaq let old_inode: Arc<LockedFATInode> = guard.find(old_name)?; 16859e481b3bSTTaq // 对目标inode上锁,以防更改 16869e481b3bSTTaq let old_inode_guard: SpinLockGuard<FATInode> = old_inode.0.lock(); 16879e481b3bSTTaq let fs = old_inode_guard.fs.upgrade().unwrap(); 16889e481b3bSTTaq // 从缓存删除 16891074eb34SSamuel Dai let _nod = guard.children.remove(&DName::from(old_name.to_uppercase())); 16909e481b3bSTTaq let old_dir = match &guard.inode_type { 16919e481b3bSTTaq FATDirEntry::File(_) | FATDirEntry::VolId(_) => { 16929e481b3bSTTaq return Err(SystemError::ENOTDIR); 16939e481b3bSTTaq } 16949e481b3bSTTaq FATDirEntry::Dir(d) => d, 16959e481b3bSTTaq FATDirEntry::UnInit => { 16962eab6dd7S曾俊 error!("FATFS: param: Inode_type uninitialized."); 16979e481b3bSTTaq return Err(SystemError::EROFS); 16989e481b3bSTTaq } 16999e481b3bSTTaq }; 17009e481b3bSTTaq // 检查文件是否存在 17019e481b3bSTTaq // old_dir.check_existence(old_name, Some(false), guard.fs.upgrade().unwrap())?; 17029e481b3bSTTaq 17039e481b3bSTTaq old_dir.rename(fs, old_name, new_name)?; 17049e481b3bSTTaq } else { 17059e481b3bSTTaq let mut old_guard = self.0.lock(); 17069e481b3bSTTaq let other: &LockedFATInode = target 17079e481b3bSTTaq .downcast_ref::<LockedFATInode>() 17089e481b3bSTTaq .ok_or(SystemError::EPERM)?; 17099e481b3bSTTaq 17109e481b3bSTTaq let new_guard = other.0.lock(); 17119e481b3bSTTaq let old_inode: Arc<LockedFATInode> = old_guard.find(old_name)?; 17129e481b3bSTTaq // 对目标inode上锁,以防更改 17139e481b3bSTTaq let old_inode_guard: SpinLockGuard<FATInode> = old_inode.0.lock(); 17149e481b3bSTTaq let fs = old_inode_guard.fs.upgrade().unwrap(); 17159e481b3bSTTaq // 从缓存删除 17161074eb34SSamuel Dai let _nod = old_guard 17171074eb34SSamuel Dai .children 17181074eb34SSamuel Dai .remove(&DName::from(old_name.to_uppercase())); 17199e481b3bSTTaq let old_dir = match &old_guard.inode_type { 17209e481b3bSTTaq FATDirEntry::File(_) | FATDirEntry::VolId(_) => { 17219e481b3bSTTaq return Err(SystemError::ENOTDIR); 17229e481b3bSTTaq } 17239e481b3bSTTaq FATDirEntry::Dir(d) => d, 17249e481b3bSTTaq FATDirEntry::UnInit => { 17252eab6dd7S曾俊 error!("FATFS: param: Inode_type uninitialized."); 17269e481b3bSTTaq return Err(SystemError::EROFS); 17279e481b3bSTTaq } 17289e481b3bSTTaq }; 17299e481b3bSTTaq let new_dir = match &new_guard.inode_type { 17309e481b3bSTTaq FATDirEntry::File(_) | FATDirEntry::VolId(_) => { 17319e481b3bSTTaq return Err(SystemError::ENOTDIR); 17329e481b3bSTTaq } 17339e481b3bSTTaq FATDirEntry::Dir(d) => d, 17349e481b3bSTTaq FATDirEntry::UnInit => { 17352eab6dd7S曾俊 error!("FATFA: param: Inode_type uninitialized."); 17369e481b3bSTTaq return Err(SystemError::EROFS); 17379e481b3bSTTaq } 17389e481b3bSTTaq }; 17399e481b3bSTTaq // 检查文件是否存在 17409e481b3bSTTaq old_dir.check_existence(old_name, Some(false), old_guard.fs.upgrade().unwrap())?; 17419e481b3bSTTaq old_dir.rename_across(fs, new_dir, old_name, new_name)?; 17429e481b3bSTTaq } 17439e481b3bSTTaq 17449e481b3bSTTaq return Ok(()); 17459e481b3bSTTaq } 17469e481b3bSTTaq 1747676b8ef6SMork fn get_entry_name(&self, ino: InodeId) -> Result<String, SystemError> { 1748004e86ffSlogin let guard: SpinLockGuard<FATInode> = self.0.lock(); 1749004e86ffSlogin if guard.metadata.file_type != FileType::Dir { 1750676b8ef6SMork return Err(SystemError::ENOTDIR); 1751004e86ffSlogin } 17526b4e7a29SLoGin match ino.into() { 1753004e86ffSlogin 0 => { 1754004e86ffSlogin return Ok(String::from(".")); 1755004e86ffSlogin } 1756004e86ffSlogin 1 => { 1757004e86ffSlogin return Ok(String::from("..")); 1758004e86ffSlogin } 1759004e86ffSlogin ino => { 1760004e86ffSlogin // 暴力遍历所有的children,判断inode id是否相同 1761004e86ffSlogin // TODO: 优化这里,这个地方性能很差! 1762004e86ffSlogin let mut key: Vec<String> = guard 1763004e86ffSlogin .children 17641074eb34SSamuel Dai .iter() 17651074eb34SSamuel Dai .filter_map(|(k, v)| { 17661074eb34SSamuel Dai if v.0.lock().metadata.inode_id.into() == ino { 17671074eb34SSamuel Dai Some(k.to_string()) 17681074eb34SSamuel Dai } else { 17691074eb34SSamuel Dai None 17701074eb34SSamuel Dai } 17716b4e7a29SLoGin }) 1772004e86ffSlogin .collect(); 1773004e86ffSlogin 1774004e86ffSlogin match key.len() { 1775676b8ef6SMork 0=>{return Err(SystemError::ENOENT);} 1776004e86ffSlogin 1=>{return Ok(key.remove(0));} 17776b4e7a29SLoGin _ => panic!("FatFS get_entry_name: key.len()={key_len}>1, current inode_id={inode_id:?}, to find={to_find:?}", key_len=key.len(), inode_id = guard.metadata.inode_id, to_find=ino) 1778004e86ffSlogin } 1779004e86ffSlogin } 1780004e86ffSlogin } 1781004e86ffSlogin } 17822dbef785SGnoCiYeH 17832dbef785SGnoCiYeH fn mknod( 17842dbef785SGnoCiYeH &self, 17852dbef785SGnoCiYeH filename: &str, 17862dbef785SGnoCiYeH mode: ModeType, 1787c566df45SLoGin _dev_t: DeviceNumber, 17882dbef785SGnoCiYeH ) -> Result<Arc<dyn IndexNode>, SystemError> { 17892dbef785SGnoCiYeH let mut inode = self.0.lock(); 17902dbef785SGnoCiYeH if inode.metadata.file_type != FileType::Dir { 17912dbef785SGnoCiYeH return Err(SystemError::ENOTDIR); 17922dbef785SGnoCiYeH } 17932dbef785SGnoCiYeH 17942dbef785SGnoCiYeH // 判断需要创建的类型 17952dbef785SGnoCiYeH if unlikely(mode.contains(ModeType::S_IFREG)) { 17962dbef785SGnoCiYeH // 普通文件 1797b5b571e0SLoGin return self.create(filename, FileType::File, mode); 17982dbef785SGnoCiYeH } 17992dbef785SGnoCiYeH 18001074eb34SSamuel Dai let filename = DName::from(filename.to_uppercase()); 18012dbef785SGnoCiYeH let nod = LockedFATInode::new( 18021074eb34SSamuel Dai filename.clone(), 18032dbef785SGnoCiYeH inode.fs.upgrade().unwrap(), 18042dbef785SGnoCiYeH inode.self_ref.clone(), 18052dbef785SGnoCiYeH FATDirEntry::File(FATFile::default()), 18062dbef785SGnoCiYeH ); 18072dbef785SGnoCiYeH 18082dbef785SGnoCiYeH if mode.contains(ModeType::S_IFIFO) { 18092dbef785SGnoCiYeH nod.0.lock().metadata.file_type = FileType::Pipe; 18102dbef785SGnoCiYeH // 创建pipe文件 18112dbef785SGnoCiYeH let pipe_inode = LockedPipeInode::new(); 18122dbef785SGnoCiYeH // 设置special_node 18132dbef785SGnoCiYeH nod.0.lock().special_node = Some(SpecialNodeData::Pipe(pipe_inode)); 18142dbef785SGnoCiYeH } else if mode.contains(ModeType::S_IFBLK) { 18152dbef785SGnoCiYeH nod.0.lock().metadata.file_type = FileType::BlockDevice; 18162dbef785SGnoCiYeH unimplemented!() 18172dbef785SGnoCiYeH } else if mode.contains(ModeType::S_IFCHR) { 18182dbef785SGnoCiYeH nod.0.lock().metadata.file_type = FileType::CharDevice; 18192dbef785SGnoCiYeH unimplemented!() 18201effcfe5SGnoCiYeH } else { 18211effcfe5SGnoCiYeH return Err(SystemError::EINVAL); 18222dbef785SGnoCiYeH } 18232dbef785SGnoCiYeH 18241074eb34SSamuel Dai inode.children.insert(filename, nod.clone()); 18252dbef785SGnoCiYeH Ok(nod) 18262dbef785SGnoCiYeH } 18272dbef785SGnoCiYeH 18282dbef785SGnoCiYeH fn special_node(&self) -> Option<SpecialNodeData> { 18292dbef785SGnoCiYeH self.0.lock().special_node.clone() 18302dbef785SGnoCiYeH } 18311074eb34SSamuel Dai 18321074eb34SSamuel Dai fn dname(&self) -> Result<DName, SystemError> { 18331074eb34SSamuel Dai Ok(self.0.lock().dname.clone()) 18341074eb34SSamuel Dai } 18351074eb34SSamuel Dai 18361074eb34SSamuel Dai fn parent(&self) -> Result<Arc<dyn IndexNode>, SystemError> { 18371074eb34SSamuel Dai self.0 18381074eb34SSamuel Dai .lock() 18391074eb34SSamuel Dai .parent 18401074eb34SSamuel Dai .upgrade() 18411074eb34SSamuel Dai .map(|item| item as Arc<dyn IndexNode>) 18421074eb34SSamuel Dai .ok_or(SystemError::EINVAL) 18431074eb34SSamuel Dai } 1844004e86ffSlogin } 1845004e86ffSlogin 1846004e86ffSlogin impl Default for FATFsInfo { 1847004e86ffSlogin fn default() -> Self { 1848004e86ffSlogin return FATFsInfo { 1849004e86ffSlogin lead_sig: FATFsInfo::LEAD_SIG, 1850004e86ffSlogin struc_sig: FATFsInfo::STRUC_SIG, 1851004e86ffSlogin free_count: 0xFFFFFFFF, 1852004e86ffSlogin next_free: RESERVED_CLUSTERS, 1853004e86ffSlogin trail_sig: FATFsInfo::TRAIL_SIG, 1854004e86ffSlogin dirty: false, 1855004e86ffSlogin offset: None, 1856004e86ffSlogin }; 1857004e86ffSlogin } 1858004e86ffSlogin } 1859004e86ffSlogin 1860004e86ffSlogin impl Cluster { 1861004e86ffSlogin pub fn new(cluster: u64) -> Self { 1862004e86ffSlogin return Cluster { 1863004e86ffSlogin cluster_num: cluster, 1864004e86ffSlogin parent_cluster: 0, 1865004e86ffSlogin }; 1866004e86ffSlogin } 1867004e86ffSlogin } 1868004e86ffSlogin 1869004e86ffSlogin /// @brief 用于迭代FAT表的内容的簇迭代器对象 1870004e86ffSlogin #[derive(Debug)] 1871004e86ffSlogin struct ClusterIter<'a> { 1872004e86ffSlogin /// 迭代器的next要返回的簇 1873004e86ffSlogin current_cluster: Option<Cluster>, 1874004e86ffSlogin /// 属于的文件系统 1875004e86ffSlogin fs: &'a FATFileSystem, 1876004e86ffSlogin } 1877004e86ffSlogin 1878004e86ffSlogin impl<'a> Iterator for ClusterIter<'a> { 1879004e86ffSlogin type Item = Cluster; 1880004e86ffSlogin 1881004e86ffSlogin fn next(&mut self) -> Option<Self::Item> { 1882004e86ffSlogin // 当前要返回的簇 1883004e86ffSlogin let ret: Option<Cluster> = self.current_cluster; 1884004e86ffSlogin 1885004e86ffSlogin // 获得下一个要返回簇 1886004e86ffSlogin let new: Option<Cluster> = match self.current_cluster { 1887004e86ffSlogin Some(c) => { 1888004e86ffSlogin let entry: Option<FATEntry> = self.fs.get_fat_entry(c).ok(); 1889004e86ffSlogin match entry { 1890004e86ffSlogin Some(FATEntry::Next(c)) => Some(c), 1891004e86ffSlogin _ => None, 1892004e86ffSlogin } 1893004e86ffSlogin } 1894004e86ffSlogin _ => None, 1895004e86ffSlogin }; 1896004e86ffSlogin 1897004e86ffSlogin self.current_cluster = new; 1898004e86ffSlogin return ret; 1899004e86ffSlogin } 1900004e86ffSlogin } 1901